ism/src/isf_info_manager.cpp

   1 /** @file isf_info_manager.cpp
   2  *  @brief Implementation of class InfoManager.
   3  */
   4
   5 /* ISF is based on SCIM 1.4.7 and extended for supporting more mobile fitable. */
   6
   7 /*
   8  * Smart Common Input Method
   9  *
  10  * Copyright (c) 2005 James Su <suzhe@tsinghua.org.cn>
  11  * Copyright (c) 2012-2016 Samsung Electronics Co., Ltd.
  12  *
  13  *
  14  * This library is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU Lesser General Public
  16  * License as published by the Free Software Foundation; either
  17  * version 2 of the License, or (at your option) any later version.
  18  *
  19  * This library is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Lesser General Public
  25  * License along with this program; if not, write to the
  26  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  27  * Boston, MA  02111-1307  USA
  28  *
  29  * Modifications by Samsung Electronics Co., Ltd.
  30  * 1. Add new signals
  31  *    a. m_signal_set_keyboard_ise and m_signal_get_keyboard_ise
  32  *    b. m_signal_focus_in and m_signal_focus_out
  33  *    c. m_signal_expand_candidate, m_signal_contract_candidate and m_signal_set_candidate_ui
  34  *    d. m_signal_get_ise_list, m_signal_get_keyboard_ise_list, m_signal_update_ise_geometry and m_signal_get_ise_information
  35  *    e. m_signal_set_active_ise_by_uuid and m_signal_get_ise_info_by_uuid
  36  *    f. m_signal_accept_connection, m_signal_close_connection and m_signal_exit
  37  * 2. Add new interface APIs in PanelClient class
  38  *    a. get_helper_manager_id (), has_helper_manager_pending_event () and filter_helper_manager_event ()
  39  *    b. update_candidate_panel_event (), update_input_panel_event () and select_aux ()
  40  *    c. candidate_more_window_show () and candidate_more_window_hide ()
  41  *    d. update_displayed_candidate_number () and update_candidate_item_layout ()
  42  *    e. stop_helper (), send_longpress_event () and update_ise_list ()
  43  *    f. filter_event (), filter_exception_event () and get_server_id ()
  44  * 3. Donot use thread to receive message
  45  * 4. Monitor socket frontend for self-recovery function
  46  *
  47  * $Id: scim_panel_agent.cpp,v 1.8.2.1 2006/01/09 14:32:18 suzhe Exp $
  48  *
  49  */
  50
  51
  52 #define Uses_SCIM_PANEL_AGENT
  53 #define Uses_SCIM_HELPER
  54 #define Uses_SCIM_EVENT
  55 #define Uses_SCIM_CONFIG
  56 #define Uses_SCIM_CONFIG_MODULE
  57 #define Uses_SCIM_CONFIG_PATH
  58 #define Uses_SCIM_UTILITY
  59
  60 #include <string.h>
  61 #include <sys/types.h>
  62 #include <sys/times.h>
  63 #include <dlog.h>
  64 #include <unistd.h>
  65 #include "scim_private.h"
  66 #include "scim.h"
  67 #include "scim_stl_map.h"
  68 #include "isf_panel_agent_manager.h"
  69 #include "isf_debug.h"
  70 #include "isf_pkg.h"
  71
  72 #ifdef LOG_TAG
  73 # undef LOG_TAG
  74 #endif
  75 #define LOG_TAG             "ISF_PANEL_EFL"
  76
  77 #define MIN_REPEAT_TIME     2.0
  78
  79 namespace scim
  80 {
  81
  82 typedef Signal0<void>
  83 InfoManagerSignalVoid;
  84
  85 typedef Signal1<void, int>
  86 InfoManagerSignalInt;
  87
  88 typedef Signal1<void, int&>
  89 InfoManagerSignalInt2;
  90
  91 typedef Signal1<void, const String&>
  92 InfoManagerSignalString;
  93
  94 typedef Signal2<void, const String&, bool>
  95 InfoManagerSignalStringBool;
  96
  97 typedef Signal2<void, String&, String&>
  98 InfoManagerSignalString2;
  99
 100 typedef Signal2<void, int, const String&>
 101 InfoManagerSignalIntString;
 102
 103 typedef Signal1<void, const PanelFactoryInfo&>
 104 InfoManagerSignalFactoryInfo;
 105
 106 typedef Signal1<void, const std::vector <PanelFactoryInfo> &>
 107 InfoManagerSignalFactoryInfoVector;
 108
 109 typedef Signal1<void, const LookupTable&>
 110 InfoManagerSignalLookupTable;
 111
 112 typedef Signal1<void, const Property&>
 113 InfoManagerSignalProperty;
 114
 115 typedef Signal1<void, const PropertyList&>
 116 InfoManagerSignalPropertyList;
 117
 118 typedef Signal2<void, int, int>
 119 InfoManagerSignalIntInt;
 120
 121 typedef Signal2<void, int&, int&>
 122 InfoManagerSignalIntInt2;
 123
 124 typedef Signal3<void, int, int, int>
 125 InfoManagerSignalIntIntInt;
 126
 127 typedef Signal3<void, const String &, const String &, const String &>
 128 InfoManagerSignalString3;
 129
 130 typedef Signal4<void, int, int, int, int>
 131 InfoManagerSignalIntIntIntInt;
 132
 133 typedef Signal2<void, int, const Property&>
 134 InfoManagerSignalIntProperty;
 135
 136 typedef Signal2<void, int, const PropertyList&>
 137 InfoManagerSignalIntPropertyList;
 138
 139 typedef Signal2<void, int, const HelperInfo&>
 140 InfoManagerSignalIntHelperInfo;
 141
 142 typedef Signal3<void, const String&, const AttributeList&, int>
 143 InfoManagerSignalAttributeStringInt;
 144
 145 typedef Signal5<void, int, int, const String&, const String&, const AttributeList&>
 146 InfoManagerSignalAttributeInt2String2;
 147
 148 typedef Signal2<void, const String&, const AttributeList&>
 149 InfoManagerSignalAttributeString;
 150
 151 typedef Signal1<void, std::vector <String> &>
 152 InfoManagerSignalStringVector;
 153
 154 typedef Signal1<bool, HELPER_ISE_INFO&>
 155 InfoManagerSignalBoolHelperInfo;
 156
 157 typedef Signal1<bool, std::vector <String> &>
 158 InfoManagerSignalBoolStringVector;
 159
 160 typedef Signal2<void, char*, std::vector <String> &>
 161 InfoManagerSignalStrStringVector;
 162
 163 typedef Signal2<bool, const String&, ISE_INFO&>
 164 InfoManagerSignalStringISEINFO;
 165
 166 typedef Signal2<bool, String, int&>
 167 InfoManagerSignalStringInt;
 168
 169 typedef Signal1<void, const KeyEvent&>
 170 InfoManagerSignalKeyEvent;
 171
 172 typedef Signal1<void, struct rectinfo&>
 173 InfoManagerSignalRect;
 174
 175 typedef Signal6<bool, String, String&, String&, int&, int&, String&>
 176 InfoManagerSignalBoolString4int2;
 177
 178 typedef Signal2<void, int, struct rectinfo&>
 179 InfoManagerSignalIntRect;
 180
 181 typedef Signal2<bool, int, String>
 182 InfoManagerSignalIntString2;
 183
 184 typedef Signal1<bool, String>
 185 InfoManagerSignalBoolString;
 186
 187 struct HelperClientStub {
 188     int id;
 189     int ref;
 190
 191     HelperClientStub (int i = 0, int r = 0) : id (i), ref (r) { }
 192 };
 193
 194 struct IMControlStub {
 195     std::vector<ISE_INFO> info;
 196     std::vector<int> count;
 197 };
 198
 199 #define DEFAULT_CONTEXT_VALUE 0xfff
 200
 201 #if SCIM_USE_STL_EXT_HASH_MAP
 202 typedef __gnu_cxx::hash_map <int, ClientInfo, __gnu_cxx::hash <int> >       ClientRepository;
 203 typedef __gnu_cxx::hash_map <int, HelperInfo, __gnu_cxx::hash <int> >       HelperInfoRepository;
 204 typedef __gnu_cxx::hash_map <uint32, String, __gnu_cxx::hash <unsigned int> > ClientContextUUIDRepository;
 205 typedef __gnu_cxx::hash_map <String, HelperClientStub, scim_hash_string>    HelperClientIndex;
 206 typedef __gnu_cxx::hash_map <String, std::vector < std::pair <uint32, String> >, scim_hash_string>    StartHelperICIndex;
 207 #elif SCIM_USE_STL_HASH_MAP
 208 typedef std::hash_map <int, ClientInfo, std::hash <int> >                   ClientRepository;
 209 typedef std::hash_map <int, HelperInfo, std::hash <int> >                   HelperInfoRepository;
 210 typedef std::hash_map <uint32, String, std::hash <unsigned int> >           ClientContextUUIDRepository;
 211 typedef std::hash_map <String, HelperClientStub, scim_hash_string>          HelperClientIndex;
 212 typedef std::hash_map <String, std::vector < std::pair <uint32, String> >, scim_hash_string>          StartHelperICIndex;
 213 #else
 214 typedef std::map <int, ClientInfo>                                          ClientRepository;
 215 typedef std::map <int, HelperInfo>                                          HelperInfoRepository;
 216 typedef std::map <uint32, String>                                           ClientContextUUIDRepository;
 217 typedef std::map <String, HelperClientStub>                                 HelperClientIndex;
 218 typedef std::map <String, std::vector < std::pair <uint32, String> > >                                StartHelperICIndex;
 219 #endif
 220
 221 typedef std::map <String, uint32>              UUIDCountRepository;
 222 typedef std::map <String, enum HelperState>    UUIDStateRepository;
 223 typedef std::map <String, int>                 StringIntRepository;
 224 typedef std::map <int, struct IMControlStub>   IMControlRepository;
 225 typedef std::map <int, int>                    IntIntRepository;
 226
 227 static uint32
 228 get_helper_ic (int client, uint32 context)
 229 {
 230     return (uint32) (client & 0xFFFF) | ((context & 0x7FFF) << 16);
 231 }
 232
 233 static void
 234 get_imengine_client_context (uint32 helper_ic, int& client, uint32& context)
 235 {
 236     client   = (int) (helper_ic & 0xFFFF);
 237     context  = ((helper_ic >> 16) & 0x7FFF);
 238 }
 239
 240 static bool
 241 clients_equal (int first, int second)
 242 {
 243     return ((first & 0xFFFF) == (second & 0xFFFF));
 244 }
 245
 246 static bool
 247 contexts_equal (uint32 first, uint32 second)
 248 {
 249     return ((first & 0x7FFF) == (second & 0x7FFF));
 250 }
 251
 252 //==================================== InfoManager ===========================
 253 class InfoManager::InfoManagerImpl
 254 {
 255     int                                 m_current_screen;
 256
 257     String                              m_config_name;
 258     String                              m_display_name;
 259
 260     int                                 m_current_socket_client;
 261     uint32                              m_current_client_context;
 262     String                              m_current_context_uuid;
 263     TOOLBAR_MODE_T                      m_current_toolbar_mode;
 264     uint32                              m_current_helper_option;
 265     String                              m_current_helper_uuid;
 266     String                              m_last_helper_uuid;
 267     String                              m_current_ise_name;
 268     int                                 m_pending_active_imcontrol_id;
 269     int                                 m_show_request_client_id;
 270     int                                 m_active_client_id;
 271     IntIntRepository                    m_panel_client_map;
 272     IntIntRepository                    m_imcontrol_map;
 273     bool                                m_should_shared_ise;
 274     bool                                m_ise_exiting;
 275     bool                                m_is_imengine_aux;
 276     bool                                m_is_imengine_candidate;
 277     bool                                m_reshow_needed;
 278
 279     std::vector<int>                    m_current_send_remoteinput_id;
 280     std::vector<int>                    m_current_recv_remoteinput_id;
 281
 282     int                                 m_last_socket_client;
 283     uint32                              m_last_client_context;
 284     String                              m_last_context_uuid;
 285
 286     char*                               m_ise_context_buffer;
 287     size_t                              m_ise_context_length;
 288
 289     ClientRepository                    m_client_repository;
 290     /*
 291     * Each Helper ISE has two socket connect between InfoManager and HelperAgent.
 292     * m_helper_info_repository records the active connection.
 293     * m_helper_active_info_repository records the passive connection.
 294     */
 295     HelperInfoRepository                m_helper_info_repository;
 296     HelperInfoRepository                m_helper_active_info_repository;
 297     HelperClientIndex                   m_helper_client_index;
 298
 299     /* when helper register, notify imcontrol client */
 300     StringIntRepository                 m_ise_pending_repository;
 301     IMControlRepository                 m_imcontrol_repository;
 302
 303     StartHelperICIndex                  m_start_helper_ic_index;
 304
 305     /* Keyboard ISE */
 306     ClientContextUUIDRepository         m_client_context_uuids;
 307
 308     /* Helper ISE */
 309     ClientContextUUIDRepository         m_client_context_helper;
 310     UUIDCountRepository                 m_helper_uuid_count;
 311
 312     InfoManagerSignalVoid                m_signal_turn_on;
 313     InfoManagerSignalVoid                m_signal_turn_off;
 314     InfoManagerSignalVoid                m_signal_show_panel;
 315     InfoManagerSignalVoid                m_signal_hide_panel;
 316     InfoManagerSignalInt                 m_signal_update_screen;
 317     InfoManagerSignalIntIntInt           m_signal_update_spot_location;
 318     InfoManagerSignalFactoryInfo         m_signal_update_factory_info;
 319     InfoManagerSignalVoid                m_signal_start_default_ise;
 320     InfoManagerSignalVoid                m_signal_stop_default_ise;
 321     InfoManagerSignalIntInt              m_signal_update_input_context;
 322     InfoManagerSignalString              m_signal_update_language_locale;
 323     InfoManagerSignalIntInt              m_signal_set_candidate_ui;
 324     InfoManagerSignalIntInt2             m_signal_get_candidate_ui;
 325     InfoManagerSignalIntInt              m_signal_set_candidate_position;
 326     InfoManagerSignalRect                m_signal_get_candidate_geometry;
 327     InfoManagerSignalRect                m_signal_get_input_panel_geometry;
 328     InfoManagerSignalString              m_signal_set_keyboard_ise;
 329     InfoManagerSignalString2             m_signal_get_keyboard_ise;
 330     InfoManagerSignalString              m_signal_show_help;
 331     InfoManagerSignalFactoryInfoVector   m_signal_show_factory_menu;
 332     InfoManagerSignalVoid                m_signal_show_preedit_string;
 333     InfoManagerSignalVoid                m_signal_show_aux_string;
 334     InfoManagerSignalVoid                m_signal_show_lookup_table;
 335     InfoManagerSignalVoid                m_signal_show_associate_table;
 336     InfoManagerSignalVoid                m_signal_hide_preedit_string;
 337     InfoManagerSignalVoid                m_signal_hide_aux_string;
 338     InfoManagerSignalVoid                m_signal_hide_lookup_table;
 339     InfoManagerSignalVoid                m_signal_hide_associate_table;
 340     InfoManagerSignalAttributeStringInt  m_signal_update_preedit_string;
 341     InfoManagerSignalAttributeInt2String2 m_signal_recapture_string;
 342     InfoManagerSignalInt                 m_signal_update_preedit_caret;
 343     InfoManagerSignalAttributeString     m_signal_update_aux_string;
 344     InfoManagerSignalLookupTable         m_signal_update_lookup_table;
 345     InfoManagerSignalLookupTable         m_signal_update_associate_table;
 346     InfoManagerSignalPropertyList        m_signal_register_properties;
 347     InfoManagerSignalProperty            m_signal_update_property;
 348     InfoManagerSignalIntPropertyList     m_signal_register_helper_properties;
 349     InfoManagerSignalIntProperty         m_signal_update_helper_property;
 350     InfoManagerSignalIntHelperInfo       m_signal_register_helper;
 351     InfoManagerSignalInt                 m_signal_remove_helper;
 352     InfoManagerSignalStringBool          m_signal_set_active_ise_by_uuid;
 353     InfoManagerSignalVoid                m_signal_focus_in;
 354     InfoManagerSignalVoid                m_signal_focus_out;
 355     InfoManagerSignalVoid                m_signal_expand_candidate;
 356     InfoManagerSignalVoid                m_signal_contract_candidate;
 357     InfoManagerSignalInt                 m_signal_select_candidate;
 358     InfoManagerSignalBoolStringVector    m_signal_get_ise_list;
 359     InfoManagerSignalBoolHelperInfo      m_signal_get_all_helper_ise_info;
 360     InfoManagerSignalStringBool          m_signal_set_has_option_helper_ise_info;
 361     InfoManagerSignalStringBool          m_signal_set_enable_helper_ise_info;
 362     InfoManagerSignalVoid                m_signal_show_helper_ise_list;
 363     InfoManagerSignalVoid                m_signal_show_helper_ise_selector;
 364     InfoManagerSignalStringInt           m_signal_is_helper_ise_enabled;
 365     InfoManagerSignalBoolString4int2     m_signal_get_ise_information;
 366     InfoManagerSignalBoolStringVector    m_signal_get_keyboard_ise_list;
 367     InfoManagerSignalIntIntIntInt        m_signal_update_ise_geometry;
 368     InfoManagerSignalStringVector        m_signal_get_language_list;
 369     InfoManagerSignalStringVector        m_signal_get_all_language;
 370     InfoManagerSignalStrStringVector     m_signal_get_ise_language;
 371     InfoManagerSignalStringISEINFO       m_signal_get_ise_info_by_uuid;
 372     InfoManagerSignalKeyEvent            m_signal_send_key_event;
 373
 374     InfoManagerSignalInt                 m_signal_accept_connection;
 375     InfoManagerSignalInt                 m_signal_close_connection;
 376     InfoManagerSignalVoid                m_signal_exit;
 377
 378     InfoManagerSignalVoid                m_signal_transaction_start;
 379     InfoManagerSignalVoid                m_signal_transaction_end;
 380
 381     InfoManagerSignalVoid                m_signal_lock;
 382     InfoManagerSignalVoid                m_signal_unlock;
 383
 384     InfoManagerSignalVoid                m_signal_show_ise;
 385     InfoManagerSignalVoid                m_signal_hide_ise;
 386
 387     InfoManagerSignalVoid                m_signal_will_show_ack;
 388     InfoManagerSignalVoid                m_signal_will_hide_ack;
 389
 390     InfoManagerSignalInt                 m_signal_set_keyboard_mode;
 391
 392     InfoManagerSignalVoid                m_signal_candidate_will_hide_ack;
 393     InfoManagerSignalInt2                m_signal_get_ise_state;
 394     InfoManagerSignalString3             m_signal_run_helper;
 395
 396     InfoManagerSignalIntRect             m_signal_get_recent_ise_geometry;
 397
 398     InfoManagerSignalStringBool          m_signal_remoteinput_send_input_message;
 399     InfoManagerSignalIntString           m_signal_remoteinput_send_surrounding_text;
 400
 401     InfoManagerSignalIntString2          m_signal_check_privilege_by_sockfd;
 402
 403     InfoManagerSignalBoolString          m_signal_launch_option_application;
 404
 405     PanelAgentManager                    m_panel_agent_manager;
 406
 407
 408 public:
 409     InfoManagerImpl ()
 410         : m_current_screen (0),
 411           m_current_socket_client (-1), m_current_client_context (0),
 412           m_current_toolbar_mode (TOOLBAR_KEYBOARD_MODE),
 413           m_current_helper_option (0),
 414           m_pending_active_imcontrol_id (-1),
 415           m_show_request_client_id (-1),
 416           m_active_client_id (-1),
 417           m_should_shared_ise (false),
 418           m_ise_exiting (false), m_is_imengine_aux (false), m_is_imengine_candidate (false),
 419           m_reshow_needed (false),
 420           m_last_socket_client (-1), m_last_client_context (0),
 421           m_ise_context_buffer (NULL), m_ise_context_length (0) {
 422         m_current_ise_name = String (_ ("English Keyboard"));
 423         m_imcontrol_repository.clear ();
 424         m_imcontrol_map.clear ();
 425         m_current_send_remoteinput_id.clear ();
 426         m_current_recv_remoteinput_id.clear ();
 427         m_panel_client_map.clear ();
 428     }
 429
 430     ~InfoManagerImpl () {
 431         delete_ise_context_buffer ();
 432     }
 433
 434     void delete_ise_context_buffer (void) {
 435         if (m_ise_context_buffer != NULL) {
 436             delete[] m_ise_context_buffer;
 437             m_ise_context_buffer = NULL;
 438             m_ise_context_length = 0;
 439         }
 440     }
 441
 442     bool initialize (InfoManager* info_manager, const ConfigPointer& config, const String& display, bool resident) {
 443
 444         m_config_name = "socket";
 445         m_display_name = display;
 446
 447         return m_panel_agent_manager.initialize (info_manager, config, display, resident);
 448     }
 449
 450     bool valid (void) const {
 451         return m_panel_agent_manager.valid ();
 452     }
 453
 454 public:
 455
 456     void stop (void) {
 457         SCIM_DEBUG_MAIN (1) << "InfoManager::stop ()\n";
 458
 459         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
 460             String helper_uuid = get_current_helper_uuid ();
 461             hide_helper (helper_uuid);
 462             stop_helper (helper_uuid, -2, 0);
 463         }
 464
 465         m_panel_agent_manager.stop ();
 466     }
 467
 468     TOOLBAR_MODE_T get_current_toolbar_mode () const {
 469         return m_current_toolbar_mode;
 470     }
 471
 472     String get_current_ise_name () const {
 473         return m_current_ise_name;
 474     }
 475
 476     String get_current_helper_uuid () const {
 477         return m_current_helper_uuid;
 478     }
 479
 480     uint32 get_current_helper_option () const {
 481         return m_current_helper_option;
 482     }
 483
 484     void set_current_ise_name (String& name) {
 485         m_current_ise_name = name;
 486     }
 487
 488     void set_current_toolbar_mode (TOOLBAR_MODE_T mode) {
 489         m_current_toolbar_mode = mode;
 490     }
 491
 492     void set_current_helper_option (uint32 option) {
 493         m_current_helper_option = option;
 494     }
 495
 496     void update_panel_event (int cmd, uint32 nType, uint32 nValue) {
 497         int    focused_client;
 498         uint32 focused_context;
 499         get_focused_context (focused_client, focused_context);
 500
 501         if (focused_client == -1 && m_active_client_id != -1) {
 502             focused_client  = m_panel_client_map[m_active_client_id];
 503             focused_context = 0;
 504         }
 505
 506         SCIM_DEBUG_MAIN (1) << __func__ << " (" << nType << ", " << nValue << "), client=" << focused_client << "\n";
 507         ClientInfo client_info = socket_get_client_info (focused_client);
 508
 509         if (client_info.type == FRONTEND_CLIENT) {
 510             m_panel_agent_manager.update_panel_event (focused_client, focused_context, cmd, nType, nValue);
 511         } else {
 512             std::cerr << __func__ << " focused client is not existed!!!" << "\n";
 513         }
 514
 515         if (m_panel_client_map[m_show_request_client_id] != focused_client) {
 516             client_info = socket_get_client_info (m_panel_client_map[m_show_request_client_id]);
 517
 518             if (client_info.type == FRONTEND_CLIENT) {
 519                 m_panel_agent_manager.update_panel_event (m_panel_client_map[m_show_request_client_id], 0, cmd, nType, nValue);
 520                 std::cerr << __func__ << " show request client=" << m_panel_client_map[m_show_request_client_id] << "\n";
 521             } else {
 522                 std::cerr << __func__ << " show request client is not existed!!!" << "\n";
 523             }
 524         }
 525     }
 526
 527     bool move_preedit_caret (uint32 position) {
 528         SCIM_DEBUG_MAIN (1) << "InfoManager::move_preedit_caret (" << position << ")\n";
 529         int client;
 530         uint32 context;
 531         lock ();
 532         get_focused_context (client, context);
 533
 534         if (client >= 0) {
 535             m_panel_agent_manager.update_preedit_caret (client, context, position);
 536         }
 537
 538         unlock ();
 539         return client >= 0;
 540     }
 541 //useless
 542 #if 0
 543     bool request_help (void) {
 544         SCIM_DEBUG_MAIN (1) << "InfoManager::request_help ()\n";
 545         int client;
 546         uint32 context;
 547         lock ();
 548         get_focused_context (client, context);
 549
 550         if (client >= 0) {
 551             m_panel_agent_manager.request_help (client, context);
 552         }
 553
 554         unlock ();
 555         return client >= 0;
 556     }
 557
 558     bool request_factory_menu (void) {
 559         SCIM_DEBUG_MAIN (1) << "InfoManager::request_factory_menu ()\n";
 560         int client;
 561         uint32 context;
 562         lock ();
 563         get_focused_context (client, context);
 564
 565         if (client >= 0) {
 566             m_panel_agent_manager.request_factory_menu (client, context);
 567         }
 568
 569         unlock ();
 570         return client >= 0;
 571     }
 572 #endif
 573
 574     //ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE
 575     bool reset_keyboard_ise (void) {
 576         SCIM_DEBUG_MAIN (1) << "InfoManager::reset_keyboard_ise ()\n";
 577         int    client = -1;
 578         uint32 context = 0;
 579         lock ();
 580         get_focused_context (client, context);
 581
 582         if (client >= 0) {
 583             m_panel_agent_manager.reset_keyboard_ise (client, context);
 584         }
 585
 586         unlock ();
 587         return client >= 0;
 588     }
 589
 590     bool update_keyboard_ise_list (void) {
 591         SCIM_DEBUG_MAIN (1) << "InfoManager::update_keyboard_ise_list ()\n";
 592         int    client = -1;
 593         uint32 context = 0;
 594         lock ();
 595         get_focused_context (client, context);
 596
 597         if (client >= 0) {
 598             m_panel_agent_manager.update_keyboard_ise_list (client, context);
 599         }
 600
 601         unlock ();
 602         return client >= 0;
 603     }
 604
 605     bool change_factory (const String&  uuid) {
 606         SCIM_DEBUG_MAIN (1) << "InfoManager::change_factory (" << uuid << ")\n";
 607         int client;
 608         uint32 context;
 609 #if 0
 610         if (scim_global_config_read (SCIM_GLOBAL_CONFIG_PRELOAD_KEYBOARD_ISE, false))
 611             m_helper_manager.preload_keyboard_ise (uuid);
 612 #endif
 613         lock ();
 614         get_focused_context (client, context);
 615
 616         if (client >= 0) {
 617             m_panel_agent_manager.change_factory (client, context, uuid);
 618         }
 619
 620         unlock ();
 621         return client >= 0;
 622     }
 623
 624     bool helper_candidate_show (void) {
 625         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
 626         bool ret = false;
 627
 628         int    client;
 629         uint32 context;
 630         get_focused_context (client, context);
 631
 632         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
 633             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
 634
 635             if (it != m_helper_client_index.end ()) {
 636                 uint32 ctx = get_helper_ic (client, context);
 637                 m_panel_agent_manager.helper_candidate_show (it->second.id, ctx, m_current_helper_uuid);
 638                 ret = true;
 639             }
 640         }
 641
 642         /* Inform wayland module that we are showing candidate window */
 643         int     focused_client;
 644         uint32  focused_context;
 645         String  focused_uuid = get_focused_context(focused_client, focused_context);
 646         m_panel_agent_manager.helper_candidate_show(focused_client, focused_context, focused_uuid);
 647
 648         return ret;
 649     }
 650
 651     bool helper_candidate_hide (void) {
 652         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
 653         bool ret = false;
 654
 655         int    client;
 656         uint32 context;
 657         get_focused_context (client, context);
 658
 659         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
 660             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
 661
 662             if (it != m_helper_client_index.end ()) {
 663                 uint32 ctx = get_helper_ic (client, context);
 664                 m_panel_agent_manager.helper_candidate_hide (it->second.id, ctx, m_current_helper_uuid);
 665                 ret = true;
 666             }
 667         }
 668
 669         /* Inform wayland module that we are hiding candidate window */
 670         int     focused_client;
 671         uint32  focused_context;
 672         String  focused_uuid = get_focused_context(focused_client, focused_context);
 673         m_panel_agent_manager.helper_candidate_hide(focused_client, focused_context, focused_uuid);
 674
 675         return ret;
 676     }
 677
 678     bool candidate_more_window_show (void) {
 679         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
 680         int    client;
 681         uint32 context;
 682         get_focused_context (client, context);
 683
 684         if (m_is_imengine_candidate) {
 685             if (client >= 0) {
 686                 m_panel_agent_manager.candidate_more_window_show (client, context);
 687                 return true;
 688             }
 689         } else {
 690             if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
 691                 HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
 692
 693                 if (it != m_helper_client_index.end ()) {
 694                     uint32 ctx = get_helper_ic (client, context);
 695                     m_panel_agent_manager.candidate_more_window_show (it->second.id, ctx);
 696                     return true;
 697                 }
 698             }
 699         }
 700
 701         return false;
 702     }
 703
 704     bool candidate_more_window_hide (void) {
 705         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
 706         int    client;
 707         uint32 context;
 708         get_focused_context (client, context);
 709
 710         if (m_is_imengine_candidate) {
 711             if (client >= 0) {
 712                 m_panel_agent_manager.candidate_more_window_hide (client, context);
 713                 return true;
 714             }
 715         } else {
 716             if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
 717                 HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
 718
 719                 if (it != m_helper_client_index.end ()) {
 720                     uint32 ctx = get_helper_ic (client, context);
 721                     m_panel_agent_manager.candidate_more_window_hide (it->second.id, ctx);
 722                     return true;
 723                 }
 724             }
 725         }
 726
 727         return false;
 728     }
 729
 730     bool update_helper_lookup_table (const LookupTable& table) {
 731         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
 732         int    client;
 733         uint32 context;
 734
 735         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
 736             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
 737
 738             if (it != m_helper_client_index.end ()) {
 739                 uint32 ctx;
 740                 get_focused_context (client, context);
 741                 ctx = get_helper_ic (client, context);
 742                 m_panel_agent_manager.update_helper_lookup_table (it->second.id, ctx, m_current_helper_uuid, table);
 743                 return true;
 744             }
 745         }
 746
 747         return false;
 748     }
 749
 750     bool select_aux (uint32 item) {
 751         SCIM_DEBUG_MAIN (1) << "InfoManager::select_aux (" << item << ")\n";
 752         int client;
 753         uint32 context;
 754         lock ();
 755         get_focused_context (client, context);
 756
 757         if (m_is_imengine_aux) {
 758             if (client >= 0) {
 759                 m_panel_agent_manager.select_aux (client, context, item);
 760             }
 761         } else {
 762             helper_select_aux (item);
 763         }
 764
 765         unlock ();
 766         return client >= 0;
 767     }
 768
 769     bool select_candidate (uint32 item) {
 770         SCIM_DEBUG_MAIN (1) << "InfoManager::select_candidate (" << item << ")\n";
 771         int client;
 772         uint32 context;
 773         lock ();
 774         get_focused_context (client, context);
 775
 776         if (m_is_imengine_candidate) {
 777             if (client >= 0) {
 778                 m_panel_agent_manager.select_candidate (client, context, item);
 779             }
 780         } else {
 781             helper_select_candidate (item);
 782         }
 783
 784         unlock ();
 785         return client >= 0;
 786     }
 787
 788     bool lookup_table_page_up (void) {
 789         SCIM_DEBUG_MAIN (1) << "InfoManager::lookup_table_page_up ()\n";
 790         int client;
 791         uint32 context;
 792         lock ();
 793         get_focused_context (client, context);
 794
 795         if (m_is_imengine_candidate) {
 796             if (client >= 0) {
 797                 m_panel_agent_manager.lookup_table_page_up (client, context);
 798             }
 799         } else {
 800             helper_lookup_table_page_up ();
 801         }
 802
 803         unlock ();
 804         return client >= 0;
 805     }
 806
 807     bool lookup_table_page_down (void) {
 808         SCIM_DEBUG_MAIN (1) << "InfoManager::lookup_table_page_down ()\n";
 809         int client;
 810         uint32 context;
 811         lock ();
 812         get_focused_context (client, context);
 813
 814         if (m_is_imengine_candidate) {
 815             if (client >= 0) {
 816                 m_panel_agent_manager.lookup_table_page_down (client, context);
 817             }
 818         } else {
 819             helper_lookup_table_page_down ();
 820         }
 821
 822         unlock ();
 823         return client >= 0;
 824     }
 825
 826     bool update_lookup_table_page_size (uint32 size) {
 827         SCIM_DEBUG_MAIN (1) << "InfoManager::update_lookup_table_page_size (" << size << ")\n";
 828         int client;
 829         uint32 context;
 830         lock ();
 831         get_focused_context (client, context);
 832
 833         if (m_is_imengine_candidate) {
 834             if (client >= 0) {
 835                 m_panel_agent_manager.update_lookup_table_page_size (client, context, size);
 836             }
 837         } else {
 838             helper_update_lookup_table_page_size (size);
 839         }
 840
 841         unlock ();
 842         return client >= 0;
 843     }
 844
 845     bool update_candidate_item_layout (const std::vector<uint32>& row_items) {
 846         SCIM_DEBUG_MAIN (1) << __func__ << " (" << row_items.size () << ")\n";
 847         int client;
 848         uint32 context;
 849         lock ();
 850         get_focused_context (client, context);
 851
 852         if (m_is_imengine_candidate) {
 853             if (client >= 0) {
 854                 m_panel_agent_manager.update_candidate_item_layout (client, context, row_items);
 855             }
 856         } else {
 857             helper_update_candidate_item_layout (row_items);
 858         }
 859
 860         unlock ();
 861         return client >= 0;
 862     }
 863
 864     bool select_associate (uint32 item) {
 865         SCIM_DEBUG_MAIN (1) << "InfoManager::select_associate (" << item << ")\n";
 866         int client;
 867         uint32 context;
 868         lock ();
 869         get_focused_context (client, context);
 870
 871         if (client >= 0) {
 872             m_panel_agent_manager.select_associate (client, context, item);
 873         }
 874
 875         unlock ();
 876         helper_select_associate (item);
 877         return client >= 0;
 878     }
 879
 880     bool associate_table_page_up (void) {
 881         SCIM_DEBUG_MAIN (1) << "InfoManager::associate_table_page_up ()\n";
 882         int client;
 883         uint32 context;
 884         lock ();
 885         get_focused_context (client, context);
 886
 887         if (client >= 0) {
 888             m_panel_agent_manager.associate_table_page_up (client, context);
 889         }
 890
 891         unlock ();
 892         helper_associate_table_page_up ();
 893         return client >= 0;
 894     }
 895
 896     bool associate_table_page_down (void) {
 897         SCIM_DEBUG_MAIN (1) << "InfoManager::associate_table_page_down ()\n";
 898         int client;
 899         uint32 context;
 900         lock ();
 901         get_focused_context (client, context);
 902
 903         if (client >= 0) {
 904             m_panel_agent_manager.associate_table_page_down (client, context);
 905         }
 906
 907         unlock ();
 908         helper_associate_table_page_down ();
 909         return client >= 0;
 910     }
 911
 912     bool update_associate_table_page_size (uint32 size) {
 913         SCIM_DEBUG_MAIN (1) << "InfoManager::update_associate_table_page_size (" << size << ")\n";
 914         int client;
 915         uint32 context;
 916         lock ();
 917         get_focused_context (client, context);
 918
 919         if (client >= 0) {
 920             m_panel_agent_manager.update_associate_table_page_size (client, context, size);
 921         }
 922
 923         unlock ();
 924         helper_update_associate_table_page_size (size);
 925         return client >= 0;
 926     }
 927
 928     bool update_displayed_candidate_number (uint32 size) {
 929         SCIM_DEBUG_MAIN (1) << __func__ << " (" << size << ")\n";
 930         int client;
 931         uint32 context;
 932         lock ();
 933         get_focused_context (client, context);
 934
 935         if (m_is_imengine_candidate) {
 936             if (client >= 0) {
 937                 m_panel_agent_manager.update_displayed_candidate_number (client, context, size);
 938             }
 939         } else {
 940             helper_update_displayed_candidate_number (size);
 941         }
 942
 943         unlock ();
 944         return client >= 0;
 945     }
 946
 947     void send_longpress_event (int type, int index) {
 948         SCIM_DEBUG_MAIN (1) << __func__ << " (" << type << ", " << index << ")\n";
 949         int    client;
 950         uint32 context;
 951         get_focused_context (client, context);
 952
 953         if (m_is_imengine_candidate) {
 954             if (client >= 0) {
 955                 m_panel_agent_manager.send_longpress_event (client, context, index);
 956             }
 957         } else {
 958             helper_longpress_candidate (index);
 959         }
 960     }
 961
 962     bool trigger_property (const String&  property) {
 963         SCIM_DEBUG_MAIN (1) << "InfoManager::trigger_property (" << property << ")\n";
 964         int client;
 965         uint32 context;
 966         lock ();
 967         get_focused_context (client, context);
 968
 969         if (client >= 0) {
 970             m_panel_agent_manager.trigger_property (client, context, property);
 971         }
 972
 973         unlock ();
 974         return client >= 0;
 975     }
 976
 977     bool start_helper (const String&  uuid, int client, uint32 context) {
 978         SCIM_DEBUG_MAIN (1) << "InfoManager::start_helper (" << uuid << ")\n";
 979         LOGD ("start ISE(%s)", uuid.c_str ());
 980
 981         if (uuid.length () <= 0)
 982             return false;
 983
 984         lock ();
 985         /*if (m_current_toolbar_mode != TOOLBAR_HELPER_MODE || m_current_helper_uuid.compare (uuid) != 0)*/ {
 986             SCIM_DEBUG_MAIN (1) << "Run_helper\n";
 987
 988             uint32 ic = get_helper_ic (m_panel_client_map[client], context);
 989             String ic_uuid;
 990             /* Get the context uuid from the client context registration table. */
 991             {
 992                 ClientContextUUIDRepository::iterator it =
 993                     m_client_context_uuids.find (get_helper_ic (m_panel_client_map[client], context));
 994
 995                 if (it != m_client_context_uuids.end ())
 996                     ic_uuid = it->second;
 997             }
 998             m_start_helper_ic_index [uuid].push_back (std::make_pair (ic, ic_uuid));
 999             m_signal_run_helper (uuid, m_config_name, m_display_name);
1000         }
1001         m_current_helper_uuid = uuid;
1002         unlock ();
1003         return true;
1004     }
1005
1006     bool stop_helper (const String& uuid, int client, uint32 context) {
1007         char buf[256] = {0};
1008         snprintf (buf, sizeof (buf), "time:%ld  pid:%d  %s  %s  prepare to stop ISE(%s)\n",
1009                   time (0), getpid (), __FILE__, __func__, uuid.c_str ());
1010         LOGD ("prepare to stop ISE(%s)", uuid.c_str ());
1011         SCIM_DEBUG_MAIN (1) << "InfoManager::stop_helper (" << uuid << ")\n";
1012
1013         if (uuid.length () <= 0)
1014             return false;
1015
1016         lock ();
1017         uint32 ctx = get_helper_ic (client, context);
1018         HelperClientIndex::iterator it = m_helper_client_index.find (uuid);
1019
1020         if (it != m_helper_client_index.end ()) {
1021             m_ise_exiting = true;
1022             m_current_helper_uuid = String ("");
1023             m_panel_agent_manager.exit (it->second.id, ctx);
1024             SCIM_DEBUG_MAIN (1) << "Stop helper\n";
1025             ISF_SAVE_LOG ("send SCIM_TRANS_CMD_EXIT message to %s", uuid.c_str ());
1026         }
1027
1028         /* Since we are stopping this helper, erase information from start_helper_ic_index too */
1029         m_start_helper_ic_index.erase (uuid);
1030
1031         unlock ();
1032         return true;
1033     }
1034
1035     void focus_out_helper (const String& uuid, int client, uint32 context) {
1036         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1037
1038         if (it != m_helper_client_index.end ()) {
1039             uint32 ctx = get_helper_ic (client, context);
1040             m_panel_agent_manager.focus_out_helper (it->second.id, ctx, uuid);
1041         }
1042     }
1043
1044     void focus_in_helper (const String& uuid, int client, uint32 context) {
1045         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1046
1047         if (it != m_helper_client_index.end ()) {
1048             uint32 ctx = get_helper_ic (client, context);
1049             m_panel_agent_manager.focus_in_helper (it->second.id, ctx, uuid);
1050         }
1051     }
1052
1053     bool show_helper (const String& uuid, char* data, size_t& len, uint32 ctx) {
1054         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1055
1056         if (it != m_helper_client_index.end ()) {
1057             Socket client_socket (it->second.id);
1058             m_panel_agent_manager.show_helper (it->second.id, ctx, uuid, data, len);
1059             m_reshow_needed = false;
1060             return true;
1061         }
1062
1063         LOGW ("Can't find %s", m_current_helper_uuid.c_str ());
1064         m_reshow_needed = true;
1065
1066         return false;
1067     }
1068
1069     void hide_helper (const String& uuid, uint32 ctx = 0) {
1070         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1071
1072         m_reshow_needed = false;
1073         if (it != m_helper_client_index.end ()) {
1074             int client;
1075             uint32 context;
1076
1077             if (ctx == 0) {
1078                 get_focused_context (client, context);
1079                 ctx = get_helper_ic (client, context);
1080             }
1081
1082             m_panel_agent_manager.hide_helper (it->second.id, ctx, uuid);
1083         }
1084     }
1085
1086     bool set_helper_mode (const String& uuid, uint32& mode) {
1087         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1088
1089         if (it != m_helper_client_index.end ()) {
1090             int client;
1091             uint32 context;
1092             uint32 ctx;
1093             get_focused_context (client, context);
1094             ctx = get_helper_ic (client, context);
1095             m_panel_agent_manager.set_helper_mode (it->second.id, ctx, uuid, mode);
1096             return true;
1097         }
1098
1099         return false;
1100     }
1101
1102     bool set_helper_language (const String& uuid, uint32& language) {
1103         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1104
1105         if (it != m_helper_client_index.end ()) {
1106             int client     = -1;
1107             uint32 context = 0;
1108             uint32 ctx;
1109             get_focused_context (client, context);
1110             ctx = get_helper_ic (client, context);
1111             m_panel_agent_manager.set_helper_language (it->second.id, ctx, uuid, language);
1112             return true;
1113         }
1114
1115         return false;
1116     }
1117
1118     bool set_helper_imdata (const String& uuid, const char* imdata, size_t& len) {
1119         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1120
1121         if (it != m_helper_client_index.end ()) {
1122             int client     = -1;
1123             uint32 context = 0;
1124             uint32 ctx;
1125             get_focused_context (client, context);
1126             ctx = get_helper_ic (client, context);
1127             m_panel_agent_manager.set_helper_imdata (it->second.id, ctx, uuid, imdata, len);
1128             return true;
1129         }
1130
1131         return false;
1132     }
1133
1134     bool set_helper_return_key_type (const String& uuid, int type) {
1135         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1136
1137         if (it != m_helper_client_index.end ()) {
1138             int client     = -1;
1139             uint32 context = 0;
1140             uint32 ctx;
1141             get_focused_context (client, context);
1142             ctx = get_helper_ic (client, context);
1143             m_panel_agent_manager.set_helper_return_key_type (it->second.id, ctx, uuid, type);
1144             return true;
1145         }
1146
1147         return false;
1148     }
1149
1150     bool get_helper_return_key_type (const String& uuid, uint32& type) {
1151         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1152
1153         if (it != m_helper_client_index.end ()) {
1154             int    client;
1155             uint32 context;
1156             uint32 ctx;
1157             get_focused_context (client, context);
1158             ctx = get_helper_ic (client, context);
1159             m_panel_agent_manager.get_helper_return_key_type (it->second.id, ctx, uuid, type);
1160             return true;
1161         }
1162
1163         return false;
1164     }
1165
1166     bool set_helper_return_key_disable (const String& uuid, bool disabled) {
1167         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1168
1169         if (it != m_helper_client_index.end ()) {
1170             int client     = -1;
1171             uint32 context = 0;
1172             uint32 ctx;
1173             get_focused_context (client, context);
1174             ctx = get_helper_ic (client, context);
1175             m_panel_agent_manager.set_helper_return_key_disable (it->second.id, ctx, uuid, disabled);
1176             return true;
1177         }
1178
1179         return false;
1180     }
1181
1182     bool get_helper_return_key_disable (const String& uuid, uint32& disabled) {
1183         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1184
1185         if (it != m_helper_client_index.end ()) {
1186             int    client;
1187             uint32 context;
1188             uint32 ctx;
1189             get_focused_context (client, context);
1190             ctx = get_helper_ic (client, context);
1191             m_panel_agent_manager.get_helper_return_key_disable (it->second.id, ctx, uuid, disabled);
1192             return true;
1193         }
1194
1195         return false;
1196     }
1197
1198     bool set_helper_layout (const String& uuid, uint32& layout) {
1199         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1200
1201         if (it != m_helper_client_index.end ()) {
1202             int client;
1203             uint32 context;
1204             uint32 ctx;
1205             get_focused_context (client, context);
1206             ctx = get_helper_ic (client, context);
1207             m_panel_agent_manager.set_helper_layout (it->second.id, ctx, uuid, layout);
1208             return true;
1209         }
1210
1211         return false;
1212     }
1213
1214     bool set_helper_input_mode (const String& uuid, uint32& mode) {
1215         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1216
1217         if (it != m_helper_client_index.end ()) {
1218             int client;
1219             uint32 context;
1220             uint32 ctx;
1221             get_focused_context (client, context);
1222             ctx = get_helper_ic (client, context);
1223             m_panel_agent_manager.set_helper_input_mode (it->second.id, ctx, uuid, mode);
1224             return true;
1225         }
1226
1227         return false;
1228     }
1229
1230     bool set_helper_input_hint (const String& uuid, uint32& hint) {
1231         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1232
1233         if (it != m_helper_client_index.end ()) {
1234             int client;
1235             uint32 context;
1236             uint32 ctx;
1237             get_focused_context (client, context);
1238             ctx = get_helper_ic (client, context);
1239             m_panel_agent_manager.set_helper_input_hint (it->second.id, ctx, uuid, hint);
1240             return true;
1241         }
1242
1243         return false;
1244     }
1245
1246     bool set_helper_bidi_direction (const String& uuid, uint32& direction) {
1247         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1248
1249         if (it != m_helper_client_index.end ()) {
1250             int client;
1251             uint32 context;
1252             uint32 ctx;
1253             get_focused_context (client, context);
1254             ctx = get_helper_ic (client, context);
1255             m_panel_agent_manager.set_helper_bidi_direction (it->second.id, ctx, uuid, direction);
1256             return true;
1257         }
1258
1259         return false;
1260     }
1261
1262     bool set_helper_caps_mode (const String& uuid, uint32& mode) {
1263         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1264
1265         if (it != m_helper_client_index.end ()) {
1266             int client;
1267             uint32 context;
1268             uint32 ctx;
1269             get_focused_context (client, context);
1270             ctx = get_helper_ic (client, context);
1271             m_panel_agent_manager.set_helper_caps_mode (it->second.id, ctx, uuid, mode);
1272             return true;
1273         }
1274
1275         return false;
1276     }
1277
1278     bool show_helper_option_window (const String& uuid) {
1279         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1280
1281         if (it != m_helper_client_index.end ()) {
1282             int client;
1283             uint32 context;
1284             uint32 ctx;
1285             get_focused_context (client, context);
1286             ctx = get_helper_ic (client, context);
1287
1288             if (!m_signal_launch_option_application (uuid)) {
1289                 LOGD ("call show helper option");
1290                 m_panel_agent_manager.show_helper_option_window (it->second.id, ctx, uuid);
1291             }
1292
1293             return true;
1294         }
1295
1296         return false;
1297     }
1298
1299     bool resume_helper_option_window (const String& uuid) {
1300         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1301
1302         if (it != m_helper_client_index.end ()) {
1303             int client;
1304             uint32 context;
1305             uint32 ctx;
1306             get_focused_context (client, context);
1307             ctx = get_helper_ic (client, context);
1308             m_panel_agent_manager.resume_helper_option_window (it->second.id, ctx, uuid);
1309             return true;
1310         }
1311
1312         return false;
1313     }
1314
1315     bool set_helper_keyboard_mode (const String& uuid, uint32& mode) {
1316         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1317
1318         if (it != m_helper_client_index.end ()) {
1319             int client;
1320             uint32 context;
1321             uint32 ctx;
1322             get_focused_context (client, context);
1323             ctx = get_helper_ic (client, context);
1324             m_panel_agent_manager.set_helper_keyboard_mode (it->second.id, ctx, uuid, mode);
1325             return true;
1326         }
1327
1328         return false;
1329     }
1330
1331     bool set_helper_prediction_hint (const String& uuid, String prediction_hint) {
1332         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1333
1334         if (it != m_helper_client_index.end ()) {
1335             int client;
1336             uint32 context;
1337             uint32 ctx;
1338             get_focused_context (client, context);
1339             ctx = get_helper_ic (client, context);
1340             m_panel_agent_manager.set_helper_prediction_hint (it->second.id, ctx, uuid, prediction_hint);
1341             return true;
1342         }
1343
1344         return false;
1345     }
1346
1347     bool set_helper_mime_type (const String& uuid, String mime_type) {
1348         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1349
1350         if (it != m_helper_client_index.end ()) {
1351             int client;
1352             uint32 context;
1353             uint32 ctx;
1354             get_focused_context (client, context);
1355             ctx = get_helper_ic (client, context);
1356             m_panel_agent_manager.set_helper_mime_type (it->second.id, ctx, uuid, mime_type);
1357             return true;
1358         }
1359
1360         return false;
1361     }
1362
1363     bool finalize_content_helper (const String& uuid, String text, uint32 cursor_pos) {
1364         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1365
1366         if (it != m_helper_client_index.end ()) {
1367             int client;
1368             uint32 context;
1369             uint32 ctx;
1370             get_focused_context (client, context);
1371             ctx = get_helper_ic (client, context);
1372             m_panel_agent_manager.finalize_content_helper (it->second.id, ctx, uuid, text, cursor_pos);
1373             return true;
1374         }
1375
1376         return false;
1377     }
1378
1379     bool set_helper_prediction_hint_data (const String& uuid, String key, String value) {
1380         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1381
1382         if (it != m_helper_client_index.end ()) {
1383             int client;
1384             uint32 context;
1385             uint32 ctx;
1386             get_focused_context (client, context);
1387             ctx = get_helper_ic (client, context);
1388             m_panel_agent_manager.set_helper_prediction_hint_data (it->second.id, ctx, uuid, key, value);
1389             return true;
1390         }
1391
1392         return false;
1393     }
1394
1395     //ISM_TRANS_CMD_SHOW_ISF_CONTROL
1396     void show_isf_panel (int client_id) {
1397         SCIM_DEBUG_MAIN (4) << "InfoManager::show_isf_panel ()\n";
1398         m_signal_show_panel ();
1399     }
1400
1401     //ISM_TRANS_CMD_SEND_REMOTE_INPUT_MESSAGE
1402     bool send_remote_input_message (int client_id, char* buf, size_t len) {
1403         SCIM_DEBUG_MAIN(4) << "InfoManager::send_remote_input_message ()\n";
1404
1405         if (buf && len > 0) {
1406             String msg (buf);
1407             m_signal_remoteinput_send_input_message (msg, true);
1408             return true;
1409         }
1410
1411         return false;
1412     }
1413
1414     void send_remote_surrounding_text (const char* text, uint32 cursor) {
1415         SCIM_DEBUG_MAIN(4) << "InfoManager::send_remote_surrounding_text ()\n";
1416
1417         m_signal_remoteinput_send_surrounding_text (cursor, text);
1418     }
1419
1420     //ISM_TRANS_CMD_HIDE_ISF_CONTROL
1421     void hide_isf_panel (int client_id) {
1422         SCIM_DEBUG_MAIN (4) << "InfoManager::hide_isf_panel ()\n";
1423         m_signal_hide_panel ();
1424     }
1425
1426     //ISM_TRANS_CMD_SHOW_ISE_PANEL
1427     void show_ise_panel (int client_id, uint32 client, uint32 context, char*   data, size_t  len) {
1428         SCIM_DEBUG_MAIN (4) << "InfoManager::show_ise_panel ()\n";
1429         String initial_uuid = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_INITIAL_ISE_UUID), String (""));
1430         String default_uuid = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), String (""));
1431         LOGD ("prepare to show ISE %d [%s] [%s]", client_id, initial_uuid.c_str (), default_uuid.c_str ());
1432         bool ret = false;
1433         m_show_request_client_id = client_id;
1434         m_active_client_id = client_id;
1435         SCIM_DEBUG_MAIN (4) << __func__ << " (client:" << client << " context:" << context << ")\n";
1436
1437         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode) {
1438             uint32 ctx = get_helper_ic (client, context);
1439             ret = show_helper (m_current_helper_uuid, data, len, ctx);
1440         }
1441
1442         /* Save ISE context for ISE panel re-showing */
1443         if (data && len > 0) {
1444             delete_ise_context_buffer ();
1445             m_ise_context_buffer = new char [len];
1446
1447             if (m_ise_context_buffer) {
1448                 m_ise_context_length = len;
1449                 memcpy (m_ise_context_buffer, data, m_ise_context_length);
1450             }
1451         }
1452
1453         if (ret) {
1454             m_signal_show_ise ();
1455         } else {
1456             m_signal_start_default_ise ();
1457         }
1458     }
1459
1460     //ISM_TRANS_CMD_HIDE_ISE_PANEL
1461     void hide_ise_panel (int client_id, uint32 client, uint32 context) {
1462         SCIM_DEBUG_MAIN (4) << "InfoManager::hide_ise_panel ()\n";
1463         LOGD ("prepare to hide ISE, %d %d", client_id, m_show_request_client_id);
1464         SCIM_DEBUG_MAIN (4) << __func__ << " (client:" << client << " context:" << context << ")\n";
1465
1466         if (m_panel_client_map[client_id] == m_current_socket_client || client_id == m_show_request_client_id) {
1467 //            && (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)) {
1468             int    focused_client;
1469             uint32 focused_context;
1470             get_focused_context (focused_client, focused_context);
1471
1472             if (focused_client == -1 && m_active_client_id != -1) {
1473                 focused_client  = m_panel_client_map[m_active_client_id];
1474                 focused_context = 0;
1475             }
1476
1477             m_signal_hide_ise ();
1478         }
1479
1480         /* Release ISE context buffer */
1481         delete_ise_context_buffer ();
1482     }
1483
1484     void hide_helper_ise (void) {
1485 #ifdef WAYLAND
1486         int    focused_client;
1487         uint32 focused_context;
1488         get_focused_context (focused_client, focused_context);
1489         m_panel_agent_manager.hide_helper_ise (focused_client, focused_context);
1490 #else
1491         m_signal_hide_ise ();
1492 #endif
1493     }
1494
1495     void launch_helper_ise (void) {
1496         SCIM_DEBUG_MAIN (4) << "InfoManager::launch_helper_ise ()\n";
1497         m_signal_start_default_ise ();
1498     }
1499
1500     void set_default_ise (const DEFAULT_ISE_T& ise) {
1501         LOGD ("set default ise : %s", ise.uuid.c_str());
1502         scim_global_config_write (String (SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), ise.uuid);
1503         scim_global_config_flush ();
1504     }
1505
1506     void set_should_shared_ise (const bool should_shared_ise) {
1507         m_should_shared_ise = should_shared_ise;
1508     }
1509     //SCIM_TRANS_CMD_PROCESS_KEY_EVENT
1510     bool process_key_event (KeyEvent& key, uint32 serial) {
1511         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1512
1513         if (it != m_helper_client_index.end ()) {
1514             int    client;
1515             uint32 context;
1516             uint32 ctx;
1517             get_focused_context (client, context);
1518             ctx = get_helper_ic (client, context);
1519             return m_panel_agent_manager.process_key_event (it->second.id, ctx, m_current_helper_uuid, key, serial);
1520         }
1521
1522         return false;
1523     }
1524
1525     //ISM_TRANS_CMD_PROCESS_INPUT_DEVICE_EVENT
1526     bool process_input_device_event(int client_id, uint32 type, const char *data, size_t len, _OUT_ uint32& result) {
1527         SCIM_DEBUG_MAIN(4) << "InfoManager::process_input_device_event ()\n";
1528         HelperClientIndex::iterator it = m_helper_client_index.find(m_current_helper_uuid);
1529
1530         if (it != m_helper_client_index.end()) {
1531             int    client;
1532             uint32 context;
1533             uint32 ctx;
1534             get_focused_context(client, context);
1535             ctx = get_helper_ic(client, context);
1536             return m_panel_agent_manager.process_input_device_event(it->second.id, ctx, m_current_helper_uuid, type, data, len, result);
1537         }
1538
1539         return false;
1540     }
1541
1542     bool get_helper_geometry (String& uuid, struct rectinfo& info) {
1543         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1544
1545         if (it != m_helper_client_index.end ()) {
1546             int    client;
1547             uint32 context;
1548             uint32 ctx;
1549             get_focused_context (client, context);
1550             ctx = get_helper_ic (client, context);
1551             return m_panel_agent_manager.get_helper_geometry (it->second.id, ctx, uuid, info);
1552         }
1553
1554         return false;
1555     }
1556
1557     bool get_helper_imdata (String& uuid, char** imdata, size_t& len) {
1558         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1559
1560         if (it != m_helper_client_index.end ()) {
1561             int    client;
1562             uint32 context;
1563             uint32 ctx;
1564             get_focused_context (client, context);
1565             ctx = get_helper_ic (client, context);
1566             m_panel_agent_manager.get_helper_imdata (it->second.id, ctx, uuid, imdata, len);
1567             return true;
1568         }
1569
1570         return false;
1571     }
1572
1573     bool get_helper_layout (String& uuid, uint32& layout) {
1574         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1575
1576         if (it != m_helper_client_index.end ()) {
1577             int    client;
1578             uint32 context;
1579             uint32 ctx;
1580             get_focused_context (client, context);
1581             ctx = get_helper_ic (client, context);
1582             m_panel_agent_manager.get_helper_layout (it->second.id, ctx, uuid, layout);
1583             return true;
1584         }
1585
1586         return false;
1587     }
1588     //ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY
1589     void get_input_panel_geometry (int client_id, _OUT_ struct rectinfo& info) {
1590         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1591         m_signal_get_input_panel_geometry (info);
1592     }
1593     //ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY
1594     void get_candidate_window_geometry (int client_id, _OUT_ struct rectinfo& info) {
1595         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1596         m_signal_get_candidate_geometry (info);
1597     }
1598     //ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE
1599     void get_ise_language_locale (int client_id, _OUT_ char** data, _OUT_ size_t& len) {
1600         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1601         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
1602             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1603
1604             if (it != m_helper_client_index.end ()) {
1605                 int    client;
1606                 uint32 context;
1607                 get_focused_context (client, context);
1608                 uint32 ctx = get_helper_ic (client, context);
1609                 m_panel_agent_manager.get_ise_language_locale (it->second.id, ctx, m_current_helper_uuid, data, len);
1610             }
1611         }
1612     }
1613
1614     void get_current_ise_geometry (rectinfo& rect) {
1615         SCIM_DEBUG_MAIN (4) << __func__ << " \n";
1616         bool           ret  = false;
1617
1618         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1619             ret = get_helper_geometry (m_current_helper_uuid, rect);
1620
1621         if (!ret) {
1622             rect.pos_x  = 0;
1623             rect.pos_y  = 0;
1624             rect.width  = 0;
1625             rect.height = 0;
1626         }
1627     }
1628
1629     void set_ise_mode (int client_id, uint32 mode) {
1630         SCIM_DEBUG_MAIN (4) << "InfoManager::set_ise_mode ()\n";
1631
1632         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1633             set_helper_mode (m_current_helper_uuid, mode);
1634     }
1635     //ISM_TRANS_CMD_SET_LAYOUT
1636     void set_ise_layout (int client_id, uint32 layout) {
1637         SCIM_DEBUG_MAIN (4) << "InfoManager::set_ise_layout ()\n";
1638
1639         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1640             set_helper_layout (m_current_helper_uuid, layout);
1641     }
1642     //ISM_TRANS_CMD_SET_INPUT_MODE
1643     void set_ise_input_mode (int client_id, uint32 input_mode) {
1644         SCIM_DEBUG_MAIN (4) << "InfoManager::set_ise_input_mode ()\n";
1645
1646         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1647             set_helper_input_mode (m_current_helper_uuid, input_mode);
1648     }
1649     //ISM_TRANS_CMD_SET_INPUT_HINT
1650     void set_ise_input_hint (int client_id, uint32 input_hint) {
1651         SCIM_DEBUG_MAIN (4) << "InfoManager::set_ise_input_hint ()\n";
1652
1653         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1654             set_helper_input_hint (m_current_helper_uuid, input_hint);
1655     }
1656     //ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION
1657     void update_ise_bidi_direction (int client_id, uint32 bidi_direction) {
1658         SCIM_DEBUG_MAIN (4) << "InfoManager::update_ise_bidi_direction ()\n";
1659
1660         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1661             set_helper_bidi_direction (m_current_helper_uuid, bidi_direction);
1662     }
1663     //ISM_TRANS_CMD_SET_ISE_LANGUAGE
1664     void set_ise_language (int client_id, uint32 language) {
1665         SCIM_DEBUG_MAIN (4) << "InfoManager::set_ise_language ()\n";
1666
1667         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1668             set_helper_language (m_current_helper_uuid, language);
1669     }
1670     //ISM_TRANS_CMD_SET_ISE_IMDATA
1671     void set_ise_imdata (int client_id, const char*   imdata, size_t  len) {
1672         SCIM_DEBUG_MAIN (4) << "InfoManager::set_ise_imdata ()\n";
1673
1674         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1675             set_helper_imdata (m_current_helper_uuid, imdata, len);
1676     }
1677     //ISM_TRANS_CMD_GET_ISE_IMDATA
1678     bool get_ise_imdata (int client_id, _OUT_ char** imdata, _OUT_ size_t& len) {
1679         SCIM_DEBUG_MAIN (4) << "InfoManager::get_ise_imdata ()\n";
1680         bool    ret    = false;
1681
1682         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1683             ret = get_helper_imdata (m_current_helper_uuid, imdata, len);
1684
1685         return ret;
1686     }
1687     //ISM_TRANS_CMD_GET_LAYOUT
1688     bool get_ise_layout (int client_id, _OUT_ uint32& layout) {
1689         SCIM_DEBUG_MAIN (4) << "InfoManager::get_ise_layout ()\n";
1690         bool   ret = false;
1691
1692         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1693             ret = get_helper_layout (m_current_helper_uuid, layout);
1694
1695         return ret;
1696     }
1697     //ISM_TRANS_CMD_GET_ISE_STATE
1698     void get_ise_state (int client_id, _OUT_ int& state) {
1699         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1700         m_signal_get_ise_state (state);
1701     }
1702     //ISM_TRANS_CMD_GET_ACTIVE_ISE
1703     void get_active_ise (int client_id, _OUT_ String& default_uuid) {
1704         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1705         default_uuid = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), String (""));
1706     }
1707     //ISM_TRANS_CMD_GET_ISE_LIST
1708     void get_ise_list (int client_id, _OUT_ std::vector<String>& strlist) {
1709         SCIM_DEBUG_MAIN (4) << "InfoManager::get_ise_list ()\n";
1710         m_signal_get_ise_list (strlist);
1711     }
1712     //ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO
1713     void get_all_helper_ise_info (int client_id, _OUT_ HELPER_ISE_INFO& info) {
1714         SCIM_DEBUG_MAIN (4) << "InfoManager::get_all_helper_ise_info ()\n";
1715         m_signal_get_all_helper_ise_info (info);
1716
1717         //1 Check if the current IME's option (setting) is available or not.
1718         for (uint32 i = 0; i < info.appid.size (); i++) {
1719             if (m_current_helper_uuid.compare (info.appid [i]) == 0) {  // Find the current IME
1720                 // If the current IME's "has_option" is unknown (-1), get it through ISM_TRANS_CMD_CHECK_OPTION_WINDOW command.
1721                 // And it's saved to ime_info DB. Then next time this will be skipped.
1722                 if (info.has_option [i] >= 2) {
1723                     HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1724
1725                     if (it != m_helper_client_index.end ()) {
1726                         int    client;
1727                         uint32 context;
1728                         get_focused_context (client, context);
1729                         uint32 ctx = get_helper_ic (client, context);
1730                         uint32 avail = static_cast<uint32> (-1);
1731                         m_panel_agent_manager.check_option_window (it->second.id, ctx, m_current_helper_uuid, avail);
1732
1733                         if (!avail) {
1734                             String setting_app = isf_pkg_get_setting_app (m_current_helper_uuid);
1735                             if (setting_app.length () > 0)
1736                                 avail = 1;
1737                         }
1738
1739                         if (avail < 2) {
1740                             info.has_option [i] = avail;
1741                             // Update "has_option" column of ime_info DB and global variable.
1742                             m_signal_set_has_option_helper_ise_info (info.appid [i], static_cast<bool> (avail));
1743                         }
1744                     }
1745                 }
1746             }
1747         }
1748     }
1749     //ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO
1750     //reply SCIM_TRANS_CMD_FAIL or SCIM_TRANS_CMD_OK
1751     void set_enable_helper_ise_info (int client_id, String appid, uint32 is_enabled) {
1752         SCIM_DEBUG_MAIN (4) << "InfoManager::set_enable_helper_ise_info ()\n";
1753         m_signal_set_enable_helper_ise_info (appid, static_cast<bool> (is_enabled));
1754     }
1755     //ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST
1756     //reply SCIM_TRANS_CMD_FAIL or SCIM_TRANS_CMD_OK
1757     void show_helper_ise_list (int client_id) {
1758         SCIM_DEBUG_MAIN (4) << "InfoManager::show_helper_ise_list ()\n";
1759         m_signal_show_helper_ise_list ();
1760     }
1761     //ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR
1762     //reply SCIM_TRANS_CMD_FAIL or SCIM_TRANS_CMD_OK
1763     void show_helper_ise_selector (int client_id) {
1764         SCIM_DEBUG_MAIN (4) << "InfoManager::show_helper_ise_selector ()\n";
1765         m_signal_show_helper_ise_selector ();
1766     }
1767     //ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED
1768     //reply
1769     void is_helper_ise_enabled (int client_id, String strAppid, _OUT_ uint32& nEnabled) {
1770         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1771         int _nEnabled = 0;
1772         m_signal_is_helper_ise_enabled (strAppid, _nEnabled);
1773         nEnabled = (uint32)_nEnabled;
1774     }
1775     //ISM_TRANS_CMD_GET_ISE_INFORMATION
1776     void get_ise_information (int client_id, String strUuid, _OUT_ String& strName, _OUT_ String& strLanguage,
1777                               _OUT_ int& nType, _OUT_ int& nOption, _OUT_ String& strModuleName) {
1778         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1779         m_signal_get_ise_information (strUuid, strName, strLanguage, nType, nOption, strModuleName);
1780     }
1781     /*
1782      * useless
1783      */
1784     void get_language_list (int client_id, _OUT_ std::vector<String>& strlist) {
1785         SCIM_DEBUG_MAIN (4) << "InfoManager::get_language_list ()\n";
1786         m_signal_get_language_list (strlist);
1787     }
1788
1789     void get_all_language (int client_id, _OUT_ std::vector<String>& strlist) {
1790         SCIM_DEBUG_MAIN (4) << "InfoManager::get_all_language ()\n";
1791         m_signal_get_all_language (strlist);
1792     }
1793     /*
1794      * useless
1795      */
1796     void get_ise_language (int client_id, char* buf, size_t len, _OUT_ std::vector<String>& strlist) {
1797         SCIM_DEBUG_MAIN (4) << "InfoManager::get_ise_language ()\n";
1798         m_signal_get_ise_language (buf, strlist);
1799     }
1800     //ISM_TRANS_CMD_RESET_ISE_OPTION
1801     //reply SCIM_TRANS_CMD_OK
1802     bool reset_ise_option (int client_id) {
1803         SCIM_DEBUG_MAIN (1) << "InfoManager::resect_ise_option ()\n";
1804         int    client = -1;
1805         uint32 context;
1806         lock ();
1807         ClientContextUUIDRepository::iterator it = m_client_context_uuids.begin ();
1808
1809         if (it != m_client_context_uuids.end ()) {
1810             get_imengine_client_context (it->first, client, context);
1811         }
1812
1813         if (client >= 0) {
1814             m_panel_agent_manager.reset_ise_option (client, context);
1815         }
1816
1817         unlock ();
1818         return client >= 0;
1819     }
1820
1821     bool find_active_ise_by_uuid (String uuid) {
1822         HelperInfoRepository::iterator iter = m_helper_info_repository.begin ();
1823
1824         for (; iter != m_helper_info_repository.end (); iter++) {
1825             if (!uuid.compare (iter->second.uuid))
1826                 return true;
1827         }
1828
1829         return false;
1830     }
1831     //ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID
1832     //reply
1833     bool set_active_ise_by_uuid (int client_id, char*  buf, size_t  len) {
1834         SCIM_DEBUG_MAIN (4) << "InfoManager::set_active_ise_by_uuid ()\n";
1835
1836         if (buf == NULL) {
1837             return false;
1838         }
1839
1840         String uuid (buf);
1841         ISE_INFO info;
1842
1843         if (!m_signal_get_ise_info_by_uuid (uuid, info)) {
1844             return false;
1845         }
1846
1847         if (info.type == TOOLBAR_KEYBOARD_MODE) {
1848             m_signal_set_active_ise_by_uuid (uuid, 1);
1849             return true;
1850         } else {
1851             m_signal_set_active_ise_by_uuid (uuid, 1);
1852         }
1853
1854         sync ();
1855
1856         if (find_active_ise_by_uuid (uuid)) {
1857             return true;
1858         } else {
1859             m_ise_pending_repository[uuid] = client_id;
1860             return false;
1861         }
1862     }
1863     //ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID
1864     //reply SCIM_TRANS_CMD_FAIL or SCIM_TRANS_CMD_OK
1865     void set_initial_ise_by_uuid (int client_id, char*  buf, size_t  len) {
1866         SCIM_DEBUG_MAIN (4) << "InfoManager::set_initial_ise_by_uuid ()\n";
1867
1868         if (buf == NULL) {
1869             return;
1870         }
1871
1872         String uuid (buf);
1873         scim_global_config_write (String (SCIM_GLOBAL_CONFIG_INITIAL_ISE_UUID), String (uuid));
1874         scim_global_config_flush ();
1875     }
1876     //ISM_TRANS_CMD_SET_RETURN_KEY_TYPE
1877     void set_ise_return_key_type (int client_id, uint32 type) {
1878         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1879
1880         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1881             set_helper_return_key_type (m_current_helper_uuid, type);
1882     }
1883     //ISM_TRANS_CMD_GET_RETURN_KEY_TYPE
1884     //reply
1885     bool get_ise_return_key_type (int client_id, _OUT_ uint32& type) {
1886         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1887         bool   ret  = false;
1888
1889         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1890             ret = get_helper_return_key_type (m_current_helper_uuid, type);
1891
1892         return ret;
1893     }
1894     //ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE
1895     void set_ise_return_key_disable (int client_id, uint32 disabled) {
1896         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1897
1898         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1899             set_helper_return_key_disable (m_current_helper_uuid, disabled);
1900     }
1901     //ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE
1902     bool get_ise_return_key_disable (int client_id, _OUT_ uint32& disabled) {
1903         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1904         bool   ret  = false;
1905
1906         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1907             ret = get_helper_return_key_disable (m_current_helper_uuid, disabled);
1908
1909         return ret;
1910     }
1911
1912     void reset_helper_context (const String& uuid) {
1913         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
1914
1915         if (it != m_helper_client_index.end ()) {
1916             int client;
1917             uint32 context;
1918             uint32 ctx;
1919             get_focused_context (client, context);
1920             ctx = get_helper_ic (client, context);
1921             m_panel_agent_manager.reset_helper_context (it->second.id, ctx, uuid);
1922         }
1923     }
1924     /*
1925      * useless
1926      */
1927     void reset_ise_context (int client_id) {
1928         SCIM_DEBUG_MAIN (4) << "InfoManager::reset_ise_context ()\n";
1929
1930         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1931             reset_helper_context (m_current_helper_uuid);
1932     }
1933     //ISM_TRANS_CMD_SET_CAPS_MODE
1934     void set_ise_caps_mode (int client_id, uint32 mode) {
1935         SCIM_DEBUG_MAIN (4) << "InfoManager::set_ise_caps_mode ()\n";
1936
1937         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
1938             set_helper_caps_mode (m_current_helper_uuid, mode);
1939     }
1940
1941     //SCIM_TRANS_CMD_RELOAD_CONFIG
1942     void reload_config (void) {
1943         SCIM_DEBUG_MAIN (1) << "InfoManager::reload_config ()\n";
1944         lock ();
1945
1946         for (ClientRepository::iterator it = m_client_repository.begin (); it != m_client_repository.end (); ++it) {
1947             if (it->second.type == FRONTEND_CLIENT || it->second.type == HELPER_CLIENT) {
1948                 m_panel_agent_manager.reload_config (it->first);
1949             }
1950         }
1951
1952         unlock ();
1953     }
1954
1955     bool exit (void) {
1956         SCIM_DEBUG_MAIN (1) << "InfoManager::exit ()\n";
1957         lock ();
1958
1959         for (ClientRepository::iterator it = m_client_repository.begin (); it != m_client_repository.end (); ++it) {
1960             m_panel_agent_manager.exit (it->first, 0);
1961         }
1962
1963         unlock ();
1964         stop ();
1965         return true;
1966     }
1967
1968     void update_ise_list (std::vector<String>& strList) {
1969         /* request PanelClient to update keyboard ise list */
1970         update_keyboard_ise_list ();
1971     }
1972     //ISM_TRANS_CMD_SEND_WILL_SHOW_ACK
1973     void will_show_ack (int client_id) {
1974         SCIM_DEBUG_MAIN (4) << "InfoManager::will_show_ack ()\n";
1975         m_signal_will_show_ack ();
1976     }
1977     //ISM_TRANS_CMD_SEND_WILL_HIDE_ACK
1978     void will_hide_ack (int client_id) {
1979         SCIM_DEBUG_MAIN (4) << "InfoManager::will_hide_ack ()\n";
1980         m_signal_will_hide_ack ();
1981     }
1982     //ISM_TRANS_CMD_RESET_DEFAULT_ISE
1983     void reset_default_ise (int client_id) {
1984         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
1985         String initial_ise = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_INITIAL_ISE_UUID), String (""));
1986
1987         if (initial_ise.length () > 0)
1988             m_signal_set_active_ise_by_uuid (initial_ise, 1);
1989         else
1990             std::cerr << "Read SCIM_GLOBAL_CONFIG_INITIAL_ISE_UUID is failed!!!\n";
1991     }
1992     //ISM_TRANS_CMD_SET_HARDWARE_KEYBOARD_MODE
1993     void set_keyboard_mode (int client_id, uint32 mode) {
1994         SCIM_DEBUG_MAIN (4) << "InfoManager::set_keyboard_mode ()\n";
1995         m_signal_set_keyboard_mode (mode);
1996         set_ise_keyboard_mode (client_id, mode);
1997     }
1998     //ISM_TRANS_CMD_SEND_CANDIDATE_WILL_HIDE_ACK
1999     void candidate_will_hide_ack (int client_id) {
2000         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "\n";
2001         m_signal_candidate_will_hide_ack ();
2002     }
2003
2004     //ISM_TRANS_CMD_GET_ACTIVE_HELPER_OPTION
2005     void get_active_helper_option (int client_id, _OUT_ uint32& option) {
2006         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
2007         option = get_current_helper_option ();
2008     }
2009     //ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW
2010     void show_ise_option_window (int client_id) {
2011         SCIM_DEBUG_MAIN (4) << "InfoManager::show_ise_option_window ()\n";
2012         String initial_uuid = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_INITIAL_ISE_UUID), String (""));
2013         String default_uuid = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), String (""));
2014         LOGD ("prepare to show ISE option window %d [%s] [%s]", client_id, initial_uuid.c_str (), default_uuid.c_str ());
2015
2016         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode) {
2017             show_helper_option_window (m_current_helper_uuid);
2018         }
2019     }
2020
2021     //ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW
2022     void resume_ise_option_window (int client_id) {
2023         SCIM_DEBUG_MAIN (4) << "InfoManager::resume_ise_option_window ()\n";
2024         String initial_uuid = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_INITIAL_ISE_UUID), String (""));
2025         String default_uuid = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), String (""));
2026         LOGD ("prepare to resume ISE option window %d [%s] [%s]", client_id, initial_uuid.c_str (), default_uuid.c_str ());
2027
2028         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode) {
2029             resume_helper_option_window (m_current_helper_uuid);
2030         }
2031     }
2032
2033     //ISM_TRANS_CMD_SET_KEYBOARD_MODE
2034     void set_ise_keyboard_mode (int client_id, uint32 mode) {
2035         SCIM_DEBUG_MAIN (4) << "InfoManager::set_ise_keyboard_mode ()\n";
2036         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
2037             set_helper_keyboard_mode (m_current_helper_uuid, mode);
2038     }
2039
2040     //ISM_TRANS_CMD_SET_PREDICTION_HINT
2041     void set_prediction_hint (int client_id, String prediction_hint) {
2042         SCIM_DEBUG_MAIN (4) << "InfoManager::set_prediction_hint ()\n";
2043         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
2044             set_helper_prediction_hint (m_current_helper_uuid, prediction_hint);
2045     }
2046
2047     //ISM_TRANS_CMD_SET_MIME_TYPE
2048     void set_ise_mime_type (int client_id, String mime_type) {
2049         SCIM_DEBUG_MAIN (4) << "InfoManager::set_mime_type ()\n";
2050         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
2051             set_helper_mime_type (m_current_helper_uuid, mime_type);
2052     }
2053
2054     //ISM_TRANS_CMD_FINALIZE_CONTENT
2055     void finalize_content (int client_id, String text, uint32 cursor_pos) {
2056         SCIM_DEBUG_MAIN (4) << "InfoManager::finalize_content ()\n";
2057         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
2058             finalize_content_helper (m_current_helper_uuid, text, cursor_pos);
2059     }
2060
2061     //ISM_TRANS_CMD_SET_PREDICTION_HINT_DATA
2062     void set_prediction_hint_data (int client_id, String key, String value) {
2063         SCIM_DEBUG_MAIN (4) << "InfoManager::set_prediction_hint_data ()\n";
2064         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
2065             set_helper_prediction_hint_data (m_current_helper_uuid, key, value);
2066     }
2067
2068     //ISM_TRANS_CMD_EXPAND_CANDIDATE
2069     void expand_candidate () {
2070         LOGD ("");
2071         m_signal_expand_candidate ();
2072     }
2073
2074     //ISM_TRANS_CMD_CONTRACT_CANDIDATE
2075     void contract_candidate () {
2076         LOGD ("");
2077         m_signal_contract_candidate ();
2078     }
2079     //ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY
2080     void get_recent_ise_geometry (int client_id, uint32 angle, _OUT_ struct rectinfo& info) {
2081         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
2082         LOGD ("");
2083         m_signal_get_recent_ise_geometry (angle, info);
2084     }
2085
2086     bool check_privilege_by_sockfd (int client_id, const String& privilege) {
2087         return m_signal_check_privilege_by_sockfd (client_id, privilege);
2088     }
2089
2090     bool remoteinput_update_preedit_string (WideString str, AttributeList &attrs, uint32 caret)
2091     {
2092         SCIM_DEBUG_MAIN(1) << "PanelAgent::update_preedit_string ()\n";
2093         int    client = -1;
2094         uint32 context = 0;
2095
2096         lock ();
2097
2098         get_focused_context (client, context);
2099         if (client >= 0) {
2100             m_panel_agent_manager.remote_update_preedit_string (client, context, str, str, attrs, caret);
2101         }
2102
2103         unlock ();
2104
2105         return client >= 0;
2106     }
2107
2108     bool remoteinput_commit_string (const WideString &str)
2109     {
2110         SCIM_DEBUG_MAIN(1) << "PanelAgent::remote_commit_string ()\n";
2111         int    client = -1;
2112         uint32 context = 0;
2113
2114         lock ();
2115
2116         get_focused_context (client, context);
2117         if (client >= 0) {
2118             m_panel_agent_manager.remote_commit_string (client, context, str);
2119         }
2120
2121         unlock ();
2122
2123         return client >= 0;
2124     }
2125
2126     bool remoteinput_send_key_event (const KeyEvent &key)
2127     {
2128         SCIM_DEBUG_MAIN(1) << "PanelAgent::remote_send_key_event ()\n";
2129         int    client = -1;
2130         uint32 context = 0;
2131
2132         get_focused_context (client, context);
2133         if (client >= 0) {
2134             m_panel_agent_manager.remote_send_key_event (client, context, key);
2135         }
2136
2137         return client >= 0;
2138     }
2139
2140     bool remoteinput_forward_key_event (const KeyEvent &key)
2141     {
2142         SCIM_DEBUG_MAIN(1) << "PanelAgent::remote_forward_key_event ()\n";
2143         int    client = -1;
2144         uint32 context = 0;
2145
2146         get_focused_context (client, context);
2147         if (client >= 0) {
2148             m_panel_agent_manager.remote_forward_key_event (client, context, key);
2149         }
2150
2151         return client >= 0;
2152     }
2153
2154     bool remoteinput_delete_surrounding_text (uint32 offset, uint32 len)
2155     {
2156         SCIM_DEBUG_MAIN(1) << "PanelAgent::remote_delete_surrounding_text ()\n";
2157         int    client = -1;
2158         uint32 context = 0;
2159
2160         get_focused_context (client, context);
2161         if (client >= 0) {
2162             m_panel_agent_manager.remote_delete_surrounding_text (client, context, offset, len);
2163         }
2164
2165         return client >= 0;
2166     }
2167
2168     void reshow_input_panel () {
2169         if (!m_reshow_needed) return;
2170
2171         /* Check whether application is already focus_in */
2172         if (m_current_socket_client != -1) {
2173             LOGD ("Re-focus in");
2174             SCIM_DEBUG_MAIN (2) << "Application is already focus_in!\n";
2175
2176             focus_in_helper (m_current_helper_uuid, m_current_socket_client, m_current_client_context);
2177             reset_keyboard_ise ();
2178         }
2179
2180         /* Check whether ISE panel is already shown */
2181         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode && m_ise_context_length > 0) {
2182             LOGD ("Re-show input_panel");
2183             SCIM_DEBUG_MAIN (2) << "Re-show ISE panel!\n";
2184
2185             int    focused_client;
2186             uint32 focused_context;
2187
2188             get_focused_context (focused_client, focused_context);
2189             if (focused_client == -1 && m_active_client_id != -1) {
2190                 focused_client  = m_panel_client_map[m_active_client_id];
2191                 focused_context = 0;
2192             }
2193
2194             m_panel_agent_manager.update_entry_metadata (focused_client, focused_context);
2195             uint32 ctx = get_helper_ic (focused_client, focused_context);
2196             bool ret = show_helper (m_current_helper_uuid, m_ise_context_buffer, m_ise_context_length, ctx);
2197             if (ret)
2198                 m_signal_show_ise ();
2199         }
2200     }
2201
2202     Connection signal_connect_turn_on (InfoManagerSlotVoid*                slot) {
2203         return m_signal_turn_on.connect (slot);
2204     }
2205
2206     Connection signal_connect_turn_off (InfoManagerSlotVoid*                slot) {
2207         return m_signal_turn_off.connect (slot);
2208     }
2209
2210     Connection signal_connect_show_panel (InfoManagerSlotVoid*                slot) {
2211         return m_signal_show_panel.connect (slot);
2212     }
2213
2214     Connection signal_connect_hide_panel (InfoManagerSlotVoid*                slot) {
2215         return m_signal_hide_panel.connect (slot);
2216     }
2217
2218     Connection signal_connect_update_screen (InfoManagerSlotInt*                 slot) {
2219         return m_signal_update_screen.connect (slot);
2220     }
2221
2222     Connection signal_connect_update_spot_location (InfoManagerSlotIntIntInt*           slot) {
2223         return m_signal_update_spot_location.connect (slot);
2224     }
2225
2226     Connection signal_connect_update_factory_info (InfoManagerSlotFactoryInfo*         slot) {
2227         return m_signal_update_factory_info.connect (slot);
2228     }
2229
2230     Connection signal_connect_start_default_ise (InfoManagerSlotVoid*                slot) {
2231         return m_signal_start_default_ise.connect (slot);
2232     }
2233
2234     Connection signal_connect_stop_default_ise (InfoManagerSlotVoid*                slot) {
2235         return m_signal_stop_default_ise.connect (slot);
2236     }
2237
2238     Connection signal_connect_set_candidate_ui (InfoManagerSlotIntInt*              slot) {
2239         return m_signal_set_candidate_ui.connect (slot);
2240     }
2241
2242     Connection signal_connect_get_candidate_ui (InfoManagerSlotIntInt2*             slot) {
2243         return m_signal_get_candidate_ui.connect (slot);
2244     }
2245
2246     Connection signal_connect_set_candidate_position (InfoManagerSlotIntInt*              slot) {
2247         return m_signal_set_candidate_position.connect (slot);
2248     }
2249
2250     Connection signal_connect_get_candidate_geometry (InfoManagerSlotRect*                slot) {
2251         return m_signal_get_candidate_geometry.connect (slot);
2252     }
2253
2254     Connection signal_connect_get_input_panel_geometry (InfoManagerSlotRect*                slot) {
2255         return m_signal_get_input_panel_geometry.connect (slot);
2256     }
2257
2258     Connection signal_connect_set_keyboard_ise (InfoManagerSlotString*              slot) {
2259         return m_signal_set_keyboard_ise.connect (slot);
2260     }
2261
2262     Connection signal_connect_get_keyboard_ise (InfoManagerSlotString2*             slot) {
2263         return m_signal_get_keyboard_ise.connect (slot);
2264     }
2265
2266     Connection signal_connect_show_help (InfoManagerSlotString*              slot) {
2267         return m_signal_show_help.connect (slot);
2268     }
2269
2270     Connection signal_connect_show_factory_menu (InfoManagerSlotFactoryInfoVector*   slot) {
2271         return m_signal_show_factory_menu.connect (slot);
2272     }
2273
2274     Connection signal_connect_show_preedit_string (InfoManagerSlotVoid*                slot) {
2275         return m_signal_show_preedit_string.connect (slot);
2276     }
2277
2278     Connection signal_connect_show_aux_string (InfoManagerSlotVoid*                slot) {
2279         return m_signal_show_aux_string.connect (slot);
2280     }
2281
2282     Connection signal_connect_show_lookup_table (InfoManagerSlotVoid*                slot) {
2283         return m_signal_show_lookup_table.connect (slot);
2284     }
2285
2286     Connection signal_connect_show_associate_table (InfoManagerSlotVoid*                slot) {
2287         return m_signal_show_associate_table.connect (slot);
2288     }
2289
2290     Connection signal_connect_hide_preedit_string (InfoManagerSlotVoid*                slot) {
2291         return m_signal_hide_preedit_string.connect (slot);
2292     }
2293
2294     Connection signal_connect_hide_aux_string (InfoManagerSlotVoid*                slot) {
2295         return m_signal_hide_aux_string.connect (slot);
2296     }
2297
2298     Connection signal_connect_hide_lookup_table (InfoManagerSlotVoid*                slot) {
2299         return m_signal_hide_lookup_table.connect (slot);
2300     }
2301
2302     Connection signal_connect_hide_associate_table (InfoManagerSlotVoid*                slot) {
2303         return m_signal_hide_associate_table.connect (slot);
2304     }
2305
2306     Connection signal_connect_update_preedit_string (InfoManagerSlotAttributeStringInt*  slot) {
2307         return m_signal_update_preedit_string.connect (slot);
2308     }
2309
2310     Connection signal_connect_update_preedit_caret (InfoManagerSlotInt*                 slot) {
2311         return m_signal_update_preedit_caret.connect (slot);
2312     }
2313
2314     Connection signal_connect_recapture_string (InfoManagerSlotAttributeInt2String2*    slot) {
2315         return m_signal_recapture_string.connect (slot);
2316     }
2317
2318     Connection signal_connect_update_aux_string (InfoManagerSlotAttributeString*     slot) {
2319         return m_signal_update_aux_string.connect (slot);
2320     }
2321
2322     Connection signal_connect_update_lookup_table (InfoManagerSlotLookupTable*         slot) {
2323         return m_signal_update_lookup_table.connect (slot);
2324     }
2325
2326     Connection signal_connect_update_associate_table (InfoManagerSlotLookupTable*         slot) {
2327         return m_signal_update_associate_table.connect (slot);
2328     }
2329
2330     Connection signal_connect_register_properties (InfoManagerSlotPropertyList*        slot) {
2331         return m_signal_register_properties.connect (slot);
2332     }
2333
2334     Connection signal_connect_update_property (InfoManagerSlotProperty*            slot) {
2335         return m_signal_update_property.connect (slot);
2336     }
2337
2338     Connection signal_connect_register_helper_properties (InfoManagerSlotIntPropertyList*     slot) {
2339         return m_signal_register_helper_properties.connect (slot);
2340     }
2341
2342     Connection signal_connect_update_helper_property (InfoManagerSlotIntProperty*         slot) {
2343         return m_signal_update_helper_property.connect (slot);
2344     }
2345
2346     Connection signal_connect_register_helper (InfoManagerSlotIntHelperInfo*       slot) {
2347         return m_signal_register_helper.connect (slot);
2348     }
2349
2350     Connection signal_connect_remove_helper (InfoManagerSlotInt*                 slot) {
2351         return m_signal_remove_helper.connect (slot);
2352     }
2353
2354     Connection signal_connect_set_active_ise_by_uuid (InfoManagerSlotStringBool*          slot) {
2355         return m_signal_set_active_ise_by_uuid.connect (slot);
2356     }
2357
2358     Connection signal_connect_focus_in (InfoManagerSlotVoid*                   slot) {
2359         return m_signal_focus_in.connect (slot);
2360     }
2361
2362     Connection signal_connect_focus_out (InfoManagerSlotVoid*                   slot) {
2363         return m_signal_focus_out.connect (slot);
2364     }
2365
2366     Connection signal_connect_expand_candidate (InfoManagerSlotVoid*                   slot) {
2367         return m_signal_expand_candidate.connect (slot);
2368     }
2369
2370     Connection signal_connect_contract_candidate (InfoManagerSlotVoid*                   slot) {
2371         return m_signal_contract_candidate.connect (slot);
2372     }
2373
2374     Connection signal_connect_select_candidate (InfoManagerSlotInt*                    slot) {
2375         return m_signal_select_candidate.connect (slot);
2376     }
2377
2378     Connection signal_connect_get_ise_list (InfoManagerSlotBoolStringVector*       slot) {
2379         return m_signal_get_ise_list.connect (slot);
2380     }
2381
2382     Connection signal_connect_get_all_helper_ise_info (InfoManagerSlotBoolHelperInfo*       slot) {
2383         return m_signal_get_all_helper_ise_info.connect (slot);
2384     }
2385
2386     Connection signal_connect_set_has_option_helper_ise_info (InfoManagerSlotStringBool*          slot) {
2387         return m_signal_set_has_option_helper_ise_info.connect (slot);
2388     }
2389
2390     Connection signal_connect_set_enable_helper_ise_info (InfoManagerSlotStringBool*          slot) {
2391         return m_signal_set_enable_helper_ise_info.connect (slot);
2392     }
2393
2394     Connection signal_connect_show_helper_ise_list (InfoManagerSlotVoid*                slot) {
2395         return m_signal_show_helper_ise_list.connect (slot);
2396     }
2397
2398     Connection signal_connect_show_helper_ise_selector (InfoManagerSlotVoid*                slot) {
2399         return m_signal_show_helper_ise_selector.connect (slot);
2400     }
2401
2402     Connection signal_connect_is_helper_ise_enabled (InfoManagerSlotStringInt*                slot) {
2403         return m_signal_is_helper_ise_enabled.connect (slot);
2404     }
2405
2406     Connection signal_connect_get_ise_information (InfoManagerSlotBoolString4int2*        slot) {
2407         return m_signal_get_ise_information.connect (slot);
2408     }
2409
2410     Connection signal_connect_get_keyboard_ise_list (InfoManagerSlotBoolStringVector*       slot) {
2411         return m_signal_get_keyboard_ise_list.connect (slot);
2412     }
2413
2414     Connection signal_connect_update_ise_geometry (InfoManagerSlotIntIntIntInt*           slot) {
2415         return m_signal_update_ise_geometry.connect (slot);
2416     }
2417
2418     Connection signal_connect_get_language_list (InfoManagerSlotStringVector*           slot) {
2419         return m_signal_get_language_list.connect (slot);
2420     }
2421
2422     Connection signal_connect_get_all_language (InfoManagerSlotStringVector*           slot) {
2423         return m_signal_get_all_language.connect (slot);
2424     }
2425
2426     Connection signal_connect_get_ise_language (InfoManagerSlotStrStringVector*        slot) {
2427         return m_signal_get_ise_language.connect (slot);
2428     }
2429
2430     Connection signal_connect_get_ise_info_by_uuid (InfoManagerSlotStringISEINFO*          slot) {
2431         return m_signal_get_ise_info_by_uuid.connect (slot);
2432     }
2433
2434     Connection signal_connect_send_key_event (InfoManagerSlotKeyEvent*               slot) {
2435         return m_signal_send_key_event.connect (slot);
2436     }
2437
2438     Connection signal_connect_accept_connection (InfoManagerSlotInt*                    slot) {
2439         return m_signal_accept_connection.connect (slot);
2440     }
2441
2442     Connection signal_connect_close_connection (InfoManagerSlotInt*                    slot) {
2443         return m_signal_close_connection.connect (slot);
2444     }
2445
2446     Connection signal_connect_exit (InfoManagerSlotVoid*                   slot) {
2447         return m_signal_exit.connect (slot);
2448     }
2449
2450     Connection signal_connect_transaction_start (InfoManagerSlotVoid*                   slot) {
2451         return m_signal_transaction_start.connect (slot);
2452     }
2453
2454     Connection signal_connect_transaction_end (InfoManagerSlotVoid*                   slot) {
2455         return m_signal_transaction_end.connect (slot);
2456     }
2457
2458     Connection signal_connect_lock (InfoManagerSlotVoid*                   slot) {
2459         return m_signal_lock.connect (slot);
2460     }
2461
2462     Connection signal_connect_unlock (InfoManagerSlotVoid*                   slot) {
2463         return m_signal_unlock.connect (slot);
2464     }
2465
2466     Connection signal_connect_update_input_context (InfoManagerSlotIntInt*                 slot) {
2467         return m_signal_update_input_context.connect (slot);
2468     }
2469
2470     Connection signal_connect_update_language_locale(InfoManagerSlotString*                 slot) {
2471         return m_signal_update_language_locale.connect(slot);
2472     }
2473
2474     Connection signal_connect_show_ise (InfoManagerSlotVoid*                slot) {
2475         return m_signal_show_ise.connect (slot);
2476     }
2477
2478     Connection signal_connect_hide_ise (InfoManagerSlotVoid*                slot) {
2479         return m_signal_hide_ise.connect (slot);
2480     }
2481
2482     Connection signal_connect_will_show_ack (InfoManagerSlotVoid*                slot) {
2483         return m_signal_will_show_ack.connect (slot);
2484     }
2485
2486     Connection signal_connect_will_hide_ack (InfoManagerSlotVoid*                slot) {
2487         return m_signal_will_hide_ack.connect (slot);
2488     }
2489
2490     Connection signal_connect_set_keyboard_mode (InfoManagerSlotInt*                slot) {
2491         return m_signal_set_keyboard_mode.connect (slot);
2492     }
2493
2494     Connection signal_connect_candidate_will_hide_ack (InfoManagerSlotVoid*                slot) {
2495         return m_signal_candidate_will_hide_ack.connect (slot);
2496     }
2497
2498     Connection signal_connect_get_ise_state (InfoManagerSlotInt2*                slot) {
2499         return m_signal_get_ise_state.connect (slot);
2500     }
2501
2502     Connection signal_connect_run_helper (InfoManagerSlotString3*                slot)
2503     {
2504         return m_signal_run_helper.connect (slot);
2505     }
2506
2507     Connection signal_connect_launch_option_application (InfoManagerSlotBoolString*                slot)
2508     {
2509         return m_signal_launch_option_application.connect (slot);
2510     }
2511
2512     Connection signal_connect_get_recent_ise_geometry (InfoManagerSlotIntRect*                slot) {
2513         return m_signal_get_recent_ise_geometry.connect (slot);
2514     }
2515
2516     Connection signal_connect_check_privilege_by_sockfd  (InfoManagerSlotIntString2* slot)
2517     {
2518         return m_signal_check_privilege_by_sockfd.connect (slot);
2519     }
2520
2521     Connection signal_connect_remoteinput_send_input_message   (InfoManagerSlotStringBool*                slot)
2522     {
2523         return m_signal_remoteinput_send_input_message.connect (slot);
2524     }
2525
2526     Connection signal_connect_remoteinput_send_surrounding_text (InfoManagerSlotIntString*                slot)
2527     {
2528         return m_signal_remoteinput_send_surrounding_text.connect (slot);
2529     }
2530
2531     //ISM_TRANS_CMD_REGISTER_PANEL_CLIENT
2532     void register_panel_client (uint32 client_id, uint32 id) {
2533         m_panel_client_map [client_id] = (int)id;
2534     }
2535     //SCIM_TRANS_CMD_PANEL_REGISTER_INPUT_CONTEXT
2536     void register_input_context (uint32 client_id, uint32 context, String  uuid) {
2537         uint32 ctx = get_helper_ic (m_panel_client_map[client_id], context);
2538         m_client_context_uuids [ctx] = uuid;
2539     }
2540     //SCIM_TRANS_CMD_PANEL_REMOVE_INPUT_CONTEXT
2541     void remove_input_context (uint32 client_id, uint32 context) {
2542         uint32 ctx = get_helper_ic (m_panel_client_map[client_id], context);
2543         m_client_context_uuids.erase (ctx);
2544
2545         if (ctx == get_helper_ic (m_current_socket_client, m_current_client_context)) {
2546             lock ();
2547             m_current_socket_client  = m_last_socket_client;
2548             m_current_client_context = m_last_client_context;
2549             m_current_context_uuid   = m_last_context_uuid;
2550             m_last_socket_client     = -1;
2551             m_last_client_context    = 0;
2552             m_last_context_uuid      = String ("");
2553
2554             if (m_current_socket_client == -1) {
2555                 unlock ();
2556                 socket_update_control_panel ();
2557             } else {
2558                 unlock ();
2559             }
2560         } else if (ctx == get_helper_ic (m_last_socket_client, m_last_client_context)) {
2561             lock ();
2562             m_last_socket_client  = -1;
2563             m_last_client_context = 0;
2564             m_last_context_uuid   = String ("");
2565             unlock ();
2566         }
2567
2568         if (m_client_context_uuids.size () == 0)
2569             m_signal_stop_default_ise ();
2570     }
2571
2572     //SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT
2573     void socket_reset_input_context (int client_id, uint32 context) {
2574         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_reset_input_context \n";
2575
2576         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
2577             socket_reset_helper_input_context (m_current_helper_uuid, m_panel_client_map[client_id], context);
2578     }
2579
2580     //SCIM_TRANS_CMD_FOCUS_IN
2581     void focus_in (int client_id, uint32 context,  String  uuid) {
2582         m_signal_focus_in ();
2583         focus_in_helper (m_current_helper_uuid, m_panel_client_map[client_id], context);
2584         SCIM_DEBUG_MAIN (2) << "PanelAgent::focus_in (" << client_id << "," << context << "," << uuid << ")\n";
2585         m_active_client_id = client_id;
2586         lock ();
2587
2588         if (m_current_socket_client >= 0) {
2589             m_last_socket_client  = m_current_socket_client;
2590             m_last_client_context = m_current_client_context;
2591             m_last_context_uuid   = m_current_context_uuid;
2592         }
2593
2594         m_current_socket_client  = m_panel_client_map[client_id];
2595         m_current_client_context = context;
2596         m_current_context_uuid   = uuid;
2597         unlock ();
2598     }
2599
2600     //SCIM_TRANS_CMD_FOCUS_OUT
2601     void focus_out (int client_id, uint32 context) {
2602         m_signal_focus_out ();
2603         lock ();
2604         focus_out_helper (m_current_helper_uuid, m_panel_client_map[client_id], context);
2605
2606         if (m_current_socket_client >= 0) {
2607             m_last_socket_client  = m_current_socket_client;
2608             m_last_client_context = m_current_client_context;
2609             m_last_context_uuid   = m_current_context_uuid;
2610         }
2611
2612         m_current_socket_client  = -1;
2613         m_current_client_context = 0;
2614         m_current_context_uuid   = String ("");
2615         unlock ();
2616     }
2617
2618     //ISM_TRANS_CMD_TURN_ON_LOG
2619     void socket_turn_on_log (uint32 isOn) {
2620         if (isOn) {
2621             DebugOutput::enable_debug (SCIM_DEBUG_AllMask);
2622             DebugOutput::set_verbose_level (7);
2623             SCIM_DEBUG_MAIN (4) << __func__ << " on\n";
2624         } else {
2625             SCIM_DEBUG_MAIN (4) << __func__ << " off\n";
2626             DebugOutput::disable_debug (SCIM_DEBUG_AllMask);
2627             DebugOutput::set_verbose_level (0);
2628         }
2629
2630         int     focused_client;
2631         uint32  focused_context;
2632         get_focused_context (focused_client, focused_context);
2633
2634         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
2635             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
2636
2637             if (it != m_helper_client_index.end ()) {
2638                 //uint32 ctx = get_helper_ic (focused_client, focused_context);
2639                 //FIXME
2640                 //m_panel_agent_manager.socket_turn_on_log (it->second.id, ctx, m_current_helper_uuid, isOn);
2641             }
2642         }
2643
2644         if (focused_client == -1) {
2645             std::cerr << __func__ << " get_focused_context is failed!!!\n";
2646             return;
2647         }
2648
2649         ClientInfo client_info = socket_get_client_info (focused_client);
2650
2651         if (client_info.type == FRONTEND_CLIENT) {
2652             //FIXME
2653             //m_panel_agent_manager.socket_turn_on_log (focused_client, focused_context, isOn);
2654         }
2655     }
2656
2657
2658     void add_client (int client_id, uint32 key, ClientType type) {
2659         LOGD ("id:%d, key:%d, type:%d", client_id, key, type);
2660         ClientInfo info;
2661         info.key = key;
2662         info.type = type;
2663         SCIM_DEBUG_MAIN (4) << "Add client to repository. Type=" << type << " key=" << key << "\n";
2664         lock ();
2665         m_client_repository [client_id] = info;
2666
2667         if (info.type == IMCONTROL_ACT_CLIENT) {
2668             m_pending_active_imcontrol_id = client_id;
2669         } else if (info.type == IMCONTROL_CLIENT) {
2670             m_imcontrol_map [m_pending_active_imcontrol_id] = client_id;
2671             m_pending_active_imcontrol_id = -1;
2672         } else if (info.type == REMOTEINPUT_ACT_CLIENT) {
2673             m_current_send_remoteinput_id.push_back (client_id);
2674         } else if (info.type == REMOTEINPUT_CLIENT) {
2675             m_current_recv_remoteinput_id.push_back (client_id);
2676         }
2677
2678         LOGD ("%d clients connecting", m_client_repository.size());
2679
2680         unlock ();
2681     }
2682
2683     void del_client (int client_id) {
2684         ClientRepository::iterator iter = m_client_repository.find(client_id);
2685         if (iter == m_client_repository.end()) {
2686             LOGW("The client with id %d does not exist in our client repository, returning", client_id);
2687             return;
2688         }
2689         lock ();
2690         m_signal_close_connection (client_id);
2691         ClientInfo client_info = socket_get_client_info (client_id);
2692         m_client_repository.erase (client_id);
2693         LOGD ("id:%d, type:%d", client_id, client_info.type);
2694 #ifdef PANEL_SERVER_AUTO_EXIT
2695         /* Exit panel if there is no connected client anymore. */
2696         if (client_info.type != UNKNOWN_CLIENT && m_client_repository.size () == 0 && !m_should_resident) {
2697             SCIM_DEBUG_MAIN (4) << "Exit Socket Server Thread.\n";
2698             server->shutdown ();
2699             m_signal_exit.emit ();
2700         }
2701 #endif
2702         unlock ();
2703
2704         if (client_info.type == FRONTEND_CLIENT) {
2705             SCIM_DEBUG_MAIN (4) << "It's a FrontEnd client.\n";
2706
2707             /* The focused client is closed. */
2708             if (m_current_socket_client == client_id) {
2709                 if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)
2710                     hide_helper (m_current_helper_uuid);
2711
2712                 lock ();
2713                 m_current_socket_client = -1;
2714                 m_current_client_context = 0;
2715                 m_current_context_uuid = String ("");
2716                 unlock ();
2717                 socket_transaction_start ();
2718                 socket_turn_off ();
2719                 socket_transaction_end ();
2720             }
2721
2722             if (m_last_socket_client == client_id) {
2723                 lock ();
2724                 m_last_socket_client = -1;
2725                 m_last_client_context = 0;
2726                 m_last_context_uuid = String ("");
2727                 unlock ();
2728             }
2729
2730             /* Erase all associated Client Context UUIDs. */
2731             std::vector <uint32> ctx_list;
2732             ClientContextUUIDRepository::iterator it = m_client_context_uuids.begin ();
2733
2734             for (; it != m_client_context_uuids.end (); ++it) {
2735                 if ((it->first & 0xFFFF) == (client_id & 0xFFFF))
2736                     ctx_list.push_back (it->first);
2737             }
2738
2739             for (size_t i = 0; i < ctx_list.size (); ++i)
2740                 m_client_context_uuids.erase (ctx_list [i]);
2741
2742             /* Erase all helperise info associated with the client */
2743             ctx_list.clear ();
2744             it = m_client_context_helper.begin ();
2745
2746             for (; it != m_client_context_helper.end (); ++it) {
2747                 if ((it->first & 0xFFFF) == (client_id & 0xFFFF)) {
2748                     ctx_list.push_back (it->first);
2749                     /* similar to stop_helper except that it will not call get_focused_context() */
2750                     String uuid = it->second;
2751
2752                     if (m_helper_uuid_count.find (uuid) != m_helper_uuid_count.end ()) {
2753                         uint32 count = m_helper_uuid_count[uuid];
2754
2755                         if (1 == count) {
2756                             m_helper_uuid_count.erase (uuid);
2757                             HelperClientIndex::iterator pise = m_helper_client_index.find (uuid);
2758
2759                             if (pise != m_helper_client_index.end ()) {
2760                                 stop_helper (uuid, pise->second.id, it->first);
2761                             }
2762
2763                             SCIM_DEBUG_MAIN (1) << "Stop HelperISE " << uuid << " ...\n";
2764                         } else {
2765                             m_helper_uuid_count[uuid] = count - 1;
2766                             focus_out_helper (uuid, (it->first & 0xFFFF), ((it->first >> 16) & 0x7FFF));
2767                             SCIM_DEBUG_MAIN (1) << "Decrement usage count of HelperISE " << uuid
2768                                                 << " to " << m_helper_uuid_count[uuid] << "\n";
2769                         }
2770                     }
2771                 }
2772             }
2773
2774             for (size_t i = 0; i < ctx_list.size (); ++i)
2775                 m_client_context_helper.erase (ctx_list [i]);
2776
2777             HelperInfoRepository::iterator iter = m_helper_info_repository.begin ();
2778
2779             for (; iter != m_helper_info_repository.end (); iter++) {
2780                 if (!m_current_helper_uuid.compare (iter->second.uuid))
2781                     if (! (iter->second.option & ISM_ISE_HIDE_IN_CONTROL_PANEL))
2782                         socket_update_control_panel ();
2783             }
2784         } else if (client_info.type == FRONTEND_ACT_CLIENT) {
2785             SCIM_DEBUG_MAIN (4) << "It's a FRONTEND_ACT_CLIENT client.\n";
2786             IntIntRepository::iterator iter2 = m_panel_client_map.find (client_id);
2787
2788             if (iter2 != m_panel_client_map.end ())
2789                 m_panel_client_map.erase (iter2);
2790         } else if (client_info.type == HELPER_CLIENT) {
2791             SCIM_DEBUG_MAIN (4) << "It's a Helper client.\n";
2792             lock ();
2793             HelperInfoRepository::iterator hiit = m_helper_info_repository.find (client_id);
2794
2795             if (hiit != m_helper_info_repository.end ()) {
2796                 bool restart = false;
2797                 String uuid = hiit->second.uuid;
2798                 HelperClientIndex::iterator it = m_helper_client_index.find (uuid);
2799
2800                 String default_uuid = scim_global_config_read (String (SCIM_GLOBAL_CONFIG_DEFAULT_ISE_UUID), String (""));
2801                 if ((hiit->second.option & SCIM_HELPER_AUTO_RESTART) &&
2802                     (default_uuid.compare (uuid) == 0 || default_uuid.compare ("") == 0) &&
2803                     (it != m_helper_client_index.end () && it->second.ref > 0)) {
2804                     restart = true;
2805                 }
2806
2807                 m_helper_client_index.erase (uuid);
2808                 m_helper_info_repository.erase (hiit);
2809
2810                 if (restart && !m_ise_exiting) {
2811                     struct tms     tiks_buf;
2812                     static clock_t start_tiks = times (&tiks_buf);
2813                     static double  clock_tiks = (double)sysconf (_SC_CLK_TCK);
2814                     clock_t curr_tiks = times (&tiks_buf);
2815                     double  secs = (double) (curr_tiks - start_tiks) / clock_tiks;
2816                     //LOGE ("time second:%f", secs);
2817                     static String  restart_uuid;
2818
2819                     if (restart_uuid != uuid || secs > MIN_REPEAT_TIME) {
2820                         scim_usleep (100000);
2821
2822                         int    client;
2823                         uint32 context;
2824                         get_focused_context(client, context);
2825
2826                         uint32 ic = get_helper_ic (client, context);
2827                         String ic_uuid;
2828                         /* Get the context uuid from the client context registration table. */
2829                         {
2830                             ClientContextUUIDRepository::iterator it =
2831                                 m_client_context_uuids.find (get_helper_ic (m_panel_client_map[client], context));
2832
2833                             if (it != m_client_context_uuids.end ())
2834                                 ic_uuid = it->second;
2835                         }
2836
2837                         m_start_helper_ic_index[uuid].push_back(std::make_pair(ic, ic_uuid));
2838                         m_signal_run_helper (uuid, m_config_name, m_display_name);
2839                         restart_uuid = uuid;
2840                         LOGE ("Auto restart soft ISE:%s", uuid.c_str ());
2841                     } else {
2842                         reset_default_ise (0);
2843                         ISF_SAVE_LOG ("Auto restart is abnormal, reset default ISE");
2844                     }
2845
2846                     start_tiks = curr_tiks;
2847                 }
2848             }
2849
2850             m_ise_exiting = false;
2851             unlock ();
2852             socket_transaction_start ();
2853             m_signal_remove_helper (client_id);
2854             socket_transaction_end ();
2855         } else if (client_info.type == HELPER_ACT_CLIENT) {
2856             SCIM_DEBUG_MAIN (4) << "It's a Helper passive client.\n";
2857             lock ();
2858             HelperInfoRepository::iterator hiit = m_helper_active_info_repository.find (client_id);
2859
2860             if (hiit != m_helper_active_info_repository.end ())
2861                 m_helper_active_info_repository.erase (hiit);
2862
2863             unlock ();
2864         } else if (client_info.type == IMCONTROL_ACT_CLIENT) {
2865             SCIM_DEBUG_MAIN (4) << "It's a IMCONTROL_ACT_CLIENT client.\n";
2866             IMControlRepository::iterator iter = m_imcontrol_repository.find (client_id);
2867
2868             if (iter != m_imcontrol_repository.end ()) {
2869                 int size = iter->second.info.size ();
2870                 int i = 0;
2871
2872                 while (i < size) {
2873                     stop_helper ((iter->second.info)[i].uuid, (iter->second.count)[i], DEFAULT_CONTEXT_VALUE);
2874
2875                     if ((iter->second.info)[i].option & ISM_ISE_HIDE_IN_CONTROL_PANEL)
2876                         m_current_helper_uuid = m_last_helper_uuid;
2877
2878                     i++;
2879                 }
2880
2881                 m_imcontrol_repository.erase (iter);
2882             }
2883
2884             IntIntRepository::iterator iter2 = m_imcontrol_map.find (client_id);
2885
2886             if (iter2 != m_imcontrol_map.end ())
2887                 m_imcontrol_map.erase (iter2);
2888         } else if (client_info.type == REMOTEINPUT_ACT_CLIENT) {
2889             SCIM_DEBUG_MAIN (4) << "It's a REMOTEINPUT_ACT_CLIENT client.\n";
2890
2891             for (unsigned int i = 0; i < m_current_send_remoteinput_id.size (); i++) {
2892                 if (m_current_send_remoteinput_id.at (i) == client_id) {
2893                     m_current_send_remoteinput_id.erase (m_current_send_remoteinput_id.begin () + i);
2894                     break;
2895                 }
2896             }
2897         } else if (client_info.type == REMOTEINPUT_CLIENT) {
2898             SCIM_DEBUG_MAIN (4) << "It's a REMOTEINPUT_CLIENT client.\n";
2899
2900             for (unsigned int i = 0; i < m_current_recv_remoteinput_id.size (); i++) {
2901                 if (m_current_recv_remoteinput_id.at (i) == client_id) {
2902                     m_current_recv_remoteinput_id.erase (m_current_recv_remoteinput_id.begin () + i);
2903                     break;
2904                 }
2905             }
2906         } else if (client_info.type == CONFIG_CLIENT) {
2907             SCIM_DEBUG_MAIN(4) << "It's a CONFIG_CLIENT client.\n";
2908         }
2909         LOGI ("clients: %d, panel clients: %d, imcontrols size: %d, helper infos: %d, \
2910 helper active infos: %d, helper client indexs: %d, ises pending: %d, \
2911 imcontrols: %d, start helper ic indexs: %d, client context uuids: %d, \
2912 client context helpers: %d, helpers uuid count: %d",
2913                m_client_repository.size(),
2914                m_panel_client_map.size(),
2915                m_imcontrol_map.size(),
2916                m_helper_info_repository.size(),
2917                m_helper_active_info_repository.size(),
2918                m_helper_client_index.size(),
2919                m_ise_pending_repository.size(),
2920                m_imcontrol_repository.size(),
2921                m_start_helper_ic_index.size(),
2922                m_client_context_uuids.size(),
2923                m_client_context_helper.size(),
2924                m_helper_uuid_count.size());
2925     }
2926
2927     const ClientInfo& socket_get_client_info (int client) {
2928         static ClientInfo null_client = { 0, UNKNOWN_CLIENT };
2929         ClientRepository::iterator it = m_client_repository.find (client);
2930
2931         if (it != m_client_repository.end ())
2932             return it->second;
2933
2934         return null_client;
2935     }
2936
2937     //SCIM_TRANS_CMD_PANEL_TURN_ON
2938     void socket_turn_on (void) {
2939         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_turn_on ()\n";
2940         m_signal_turn_on ();
2941     }
2942     //SCIM_TRANS_CMD_PANEL_TURN_OFF
2943     void socket_turn_off (void) {
2944         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_turn_off ()\n";
2945         m_signal_turn_off ();
2946     }
2947     //SCIM_TRANS_CMD_UPDATE_SCREEN
2948     void socket_update_screen (int client_id, uint32 num) {
2949         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_screen ()\n";
2950
2951         if (((int) num) != m_current_screen) {
2952             SCIM_DEBUG_MAIN (4) << "New Screen number = " << num << "\n";
2953             m_signal_update_screen ((int) num);
2954             helper_all_update_screen ((int) num);
2955             m_current_screen = (num);
2956         }
2957     }
2958     //SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION
2959     void socket_update_spot_location (uint32 x, uint32 y, uint32 top_y) {
2960         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_spot_location ()\n";
2961         SCIM_DEBUG_MAIN (4) << "New Spot location x=" << x << " y=" << y << "\n";
2962         m_signal_update_spot_location ((int)x, (int)y, (int)top_y);
2963         helper_all_update_spot_location ((int)x, (int)y);
2964     }
2965     //ISM_TRANS_CMD_UPDATE_CURSOR_POSITION
2966     void socket_update_cursor_position (uint32 cursor_pos) {
2967         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_cursor_position ()\n";
2968         SCIM_DEBUG_MAIN (4) << "New cursor position pos=" << cursor_pos << "\n";
2969         helper_all_update_cursor_position ((int)cursor_pos);
2970     }
2971     //ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT
2972     void socket_update_surrounding_text (String text, uint32 cursor) {
2973         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
2974         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
2975
2976         if (it != m_helper_client_index.end ()) {
2977             int    client;
2978             uint32 context;
2979             uint32 ctx;
2980             lock ();
2981             get_focused_context (client, context);
2982             ctx = get_helper_ic (client, context);
2983             m_panel_agent_manager.socket_update_surrounding_text (it->second.id, ctx, m_current_helper_uuid, text, cursor);
2984             unlock ();
2985         }
2986     }
2987
2988     void remoteinput_callback_focus_in () {
2989         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
2990
2991         for (unsigned int i = 0; i < m_current_recv_remoteinput_id.size (); i++) {
2992             lock();
2993             m_panel_agent_manager.socket_remoteinput_focus_in (m_current_recv_remoteinput_id.at (i));
2994             unlock ();
2995         }
2996     }
2997
2998     void remoteinput_callback_focus_out () {
2999         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
3000
3001         for (unsigned int i = 0; i < m_current_recv_remoteinput_id.size (); i++) {
3002             lock();
3003             m_panel_agent_manager.socket_remoteinput_focus_out (m_current_recv_remoteinput_id.at (i));
3004             unlock ();
3005         }
3006     }
3007
3008     void remoteinput_callback_entry_metadata (uint32 hint, uint32 layout, int variation, uint32 autocapital_type, int return_key_disabled) {
3009         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
3010
3011         for (unsigned int i = 0; i < m_current_recv_remoteinput_id.size (); i++) {
3012             lock();
3013             m_panel_agent_manager.socket_remoteinput_entry_metadata (m_current_recv_remoteinput_id.at (i), hint, layout, variation, autocapital_type, return_key_disabled);
3014             unlock ();
3015         }
3016     }
3017
3018     void remoteinput_callback_surrounding_text (String text, uint32 cursor) {
3019         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
3020
3021         for (unsigned int i = 0; i < m_current_recv_remoteinput_id.size (); i++) {
3022             lock();
3023             m_panel_agent_manager.socket_remoteinput_surrounding_text (m_current_recv_remoteinput_id.at (i), text, cursor);
3024             unlock ();
3025         }
3026     }
3027
3028     void remoteinput_callback_input_resource (uint32 input_resource) {
3029         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
3030
3031         for (unsigned int i = 0; i < m_current_recv_remoteinput_id.size (); i++) {
3032             lock();
3033             m_panel_agent_manager.socket_remoteinput_input_resource (m_current_recv_remoteinput_id.at (i), input_resource);
3034             unlock ();
3035         }
3036     }
3037
3038     //ISM_TRANS_CMD_UPDATE_SELECTION
3039     void socket_update_selection (String text) {
3040         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << "...\n";
3041         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
3042
3043         if (it != m_helper_client_index.end ()) {
3044             int    client;
3045             uint32 context;
3046             uint32 ctx;
3047             lock ();
3048             get_focused_context (client, context);
3049             ctx = get_helper_ic (client, context);
3050             m_panel_agent_manager.socket_update_selection (it->second.id, ctx, m_current_helper_uuid, text);
3051             unlock ();
3052         }
3053     }
3054     //SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO
3055     void socket_update_factory_info (PanelFactoryInfo& info) {
3056         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_factory_info ()\n";
3057         SCIM_DEBUG_MAIN (4) << "New Factory info uuid=" << info.uuid << " name=" << info.name << "\n";
3058         info.lang = scim_get_normalized_language (info.lang);
3059         m_signal_update_factory_info (info);
3060     }
3061     //SCIM_TRANS_CMD_PANEL_SHOW_HELP
3062     void socket_show_help (String help) {
3063         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_show_help ()\n";
3064         m_signal_show_help (help);
3065     }
3066     //SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU
3067     void socket_show_factory_menu (std::vector <PanelFactoryInfo>& vec) {
3068         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_show_factory_menu ()\n";
3069
3070         if (vec.size ())
3071             m_signal_show_factory_menu (vec);
3072     }
3073
3074     //SCIM_TRANS_CMD_SHOW_PREEDIT_STRING
3075     void socket_show_preedit_string (void) {
3076         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_show_preedit_string ()\n";
3077         m_signal_show_preedit_string ();
3078     }
3079     //SCIM_TRANS_CMD_SHOW_AUX_STRING
3080     void socket_show_aux_string (void) {
3081         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_show_aux_string ()\n";
3082         m_signal_show_aux_string ();
3083     }
3084     //SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE
3085     void socket_show_lookup_table (void) {
3086         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_show_lookup_table ()\n";
3087         m_signal_show_lookup_table ();
3088     }
3089     //ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE
3090     void socket_show_associate_table (void) {
3091         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_show_associate_table ()\n";
3092         m_signal_show_associate_table ();
3093     }
3094     //SCIM_TRANS_CMD_HIDE_PREEDIT_STRING
3095     void socket_hide_preedit_string (void) {
3096         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_hide_preedit_string ()\n";
3097         m_signal_hide_preedit_string ();
3098     }
3099     //SCIM_TRANS_CMD_HIDE_AUX_STRING
3100     void socket_hide_aux_string (void) {
3101         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_hide_aux_string ()\n";
3102         m_signal_hide_aux_string ();
3103     }
3104     //SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE
3105     void socket_hide_lookup_table (void) {
3106         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_hide_lookup_table ()\n";
3107         m_signal_hide_lookup_table ();
3108     }
3109     //ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE
3110     void socket_hide_associate_table (void) {
3111         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_hide_associate_table ()\n";
3112         m_signal_hide_associate_table ();
3113     }
3114     //SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING
3115     void socket_update_preedit_string (String& str, const AttributeList& attrs, uint32 caret) {
3116         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_preedit_string ()\n";
3117         m_signal_update_preedit_string (str, attrs, (int) caret);
3118     }
3119     //SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET
3120     void socket_update_preedit_caret (uint32 caret) {
3121         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_preedit_caret ()\n";
3122         m_signal_update_preedit_caret ((int) caret);
3123     }
3124     //ISM_TRANS_CMD_RECAPTURE_STRING
3125     void socket_recapture_string (int offset, int len, String& preedit, String& commit, const AttributeList& attrs) {
3126         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_preedit_caret ()\n";
3127         m_signal_recapture_string (offset, len, preedit, commit, attrs);
3128     }
3129     //SCIM_TRANS_CMD_UPDATE_AUX_STRING
3130     void socket_update_aux_string (String& str, const AttributeList& attrs) {
3131         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_aux_string ()\n";
3132         m_signal_update_aux_string (str, attrs);
3133         m_is_imengine_aux = true;
3134     }
3135     //SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE
3136     void socket_update_lookup_table (const LookupTable& table) {
3137         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_lookup_table ()\n";
3138         //FIXME:
3139         //g_isf_candidate_table = _isf_candidate_table;
3140         m_signal_update_lookup_table (table);
3141         m_is_imengine_candidate = true;
3142     }
3143     //ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE
3144     void socket_update_associate_table (const LookupTable& table) {
3145         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_associate_table ()\n";
3146         m_signal_update_associate_table (table);
3147     }
3148
3149     void socket_update_control_panel (void) {
3150         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_control_panel ()\n";
3151         String name, uuid;
3152         m_signal_get_keyboard_ise (name, uuid);
3153         PanelFactoryInfo info;
3154
3155         if (name.length () > 0)
3156             info = PanelFactoryInfo (uuid, name, String (""), String (""));
3157         else
3158             info = PanelFactoryInfo (String (""), String (_ ("English Keyboard")), String ("C"), String (SCIM_KEYBOARD_ICON_FILE));
3159
3160         m_signal_update_factory_info (info);
3161     }
3162     //SCIM_TRANS_CMD_REGISTER_PROPERTIES
3163     void socket_register_properties (const PropertyList& properties) {
3164         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_register_properties ()\n";
3165         m_signal_register_properties (properties);
3166     }
3167     //SCIM_TRANS_CMD_UPDATE_PROPERTY
3168     void socket_update_property (const Property& property) {
3169         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_update_property ()\n";
3170         m_signal_update_property (property);
3171     }
3172     //ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST
3173     void socket_get_keyboard_ise_list (String& uuid) {
3174         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_get_keyboard_ise_list ()\n";
3175         std::vector<String> list;
3176         list.clear ();
3177         m_signal_get_keyboard_ise_list (list);
3178         HelperClientIndex::iterator it = m_helper_client_index.find (uuid);
3179
3180         if (it != m_helper_client_index.end ()) {
3181             int    client;
3182             uint32 context;
3183             get_focused_context (client, context);
3184             uint32 ctx = get_helper_ic (client, context);
3185             m_panel_agent_manager.socket_get_keyboard_ise_list (it->second.id, ctx, uuid, list);
3186         }
3187     }
3188     //ISM_TRANS_CMD_SET_CANDIDATE_UI
3189     void socket_set_candidate_ui (uint32 portrait_line, uint32 mode) {
3190         SCIM_DEBUG_MAIN (4) << __func__ << " \n";
3191         m_signal_set_candidate_ui (portrait_line, mode);
3192     }
3193     //ISM_TRANS_CMD_GET_CANDIDATE_UI
3194     void socket_get_candidate_ui (String uuid) {
3195         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_get_candidate_ui ()\n";
3196         int style = 0, mode = 0;
3197         m_signal_get_candidate_ui (style, mode);
3198         HelperClientIndex::iterator it = m_helper_client_index.find (uuid);
3199
3200         if (it != m_helper_client_index.end ()) {
3201             int    client;
3202             uint32 context;
3203             get_focused_context (client, context);
3204             uint32 ctx = get_helper_ic (client, context);
3205             m_panel_agent_manager.socket_get_candidate_ui (it->second.id, ctx, uuid, style, mode);
3206         }
3207     }
3208     //ISM_TRANS_CMD_SET_CANDIDATE_POSITION
3209     void socket_set_candidate_position (uint32 left, uint32 top) {
3210         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_set_candidate_position ()\n";
3211         m_signal_set_candidate_position (left, top);
3212     }
3213     //ISM_TRANS_CMD_HIDE_CANDIDATE
3214     void socket_hide_candidate (void) {
3215         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_hide_candidate ()\n";
3216         m_signal_hide_preedit_string ();
3217         m_signal_hide_aux_string ();
3218         m_signal_hide_lookup_table ();
3219         m_signal_hide_associate_table ();
3220     }
3221     //ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY
3222     void socket_get_candidate_geometry (String& uuid) {
3223         SCIM_DEBUG_MAIN (4) << __func__ << " \n";
3224         HelperClientIndex::iterator it = m_helper_client_index.find (uuid);
3225
3226         if (it != m_helper_client_index.end ()) {
3227             struct rectinfo info = {0, 0, 0, 0};
3228             m_signal_get_candidate_geometry (info);
3229             int    client;
3230             uint32 context;
3231             get_focused_context (client, context);
3232             uint32 ctx = get_helper_ic (client, context);
3233             m_panel_agent_manager.socket_get_candidate_geometry (it->second.id, ctx, uuid, info);
3234         }
3235     }
3236     //ISM_TRANS_CMD_SET_KEYBOARD_ISE_BY_UUID
3237     void socket_set_keyboard_ise (String uuid) {
3238         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_set_keyboard_ise ()\n";
3239         LOGD ("");
3240         m_signal_set_keyboard_ise (uuid);
3241     }
3242     //ISM_TRANS_CMD_SELECT_CANDIDATE
3243     void socket_helper_select_candidate (uint32 index) {
3244         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_set_keyboard_ise ()\n";
3245         LOGD ("");
3246         m_signal_select_candidate (index);
3247     }
3248     //ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY
3249     void socket_helper_update_ise_geometry (int client, uint32 x, uint32 y, uint32 width, uint32 height) {
3250         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
3251         LOGD ("");
3252         int    focused_client;
3253         uint32 focused_context;
3254         HelperInfoRepository::iterator it = m_helper_active_info_repository.find (client);
3255
3256         if (it != m_helper_active_info_repository.end ()) {
3257             if (it->second.uuid == m_current_helper_uuid) {
3258                 m_signal_update_ise_geometry (x, y, width, height);
3259
3260                 get_focused_context (focused_client, focused_context);
3261                 ClientInfo client_info = socket_get_client_info (focused_client);
3262                 if (client_info.type == FRONTEND_CLIENT) {
3263                     m_panel_agent_manager.update_ise_geometry (focused_client, focused_context, x, y, width, height);
3264                 }
3265             }
3266         }
3267     }
3268     //ISM_TRANS_CMD_GET_KEYBOARD_ISE
3269     void socket_get_keyboard_ise (String uuid) {
3270         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_get_keyboard_ise ()\n";
3271         String ise_name, ise_uuid;
3272         int    client  = -1;
3273         uint32 context = 0;
3274         uint32 ctx     = 0;
3275         get_focused_context (client, context);
3276         ctx = get_helper_ic (client, context);
3277
3278         if (m_client_context_uuids.find (ctx) != m_client_context_uuids.end ())
3279             ise_uuid = m_client_context_uuids[ctx];
3280
3281         m_signal_get_keyboard_ise (ise_name, ise_uuid);
3282         HelperClientIndex::iterator it = m_helper_client_index.find (uuid);
3283
3284         if (it != m_helper_client_index.end ()) {
3285             get_focused_context (client, context);
3286             ctx = get_helper_ic (client, context);
3287             m_panel_agent_manager.socket_get_keyboard_ise (it->second.id, ctx, uuid, ise_name, ise_uuid);
3288         }
3289     }
3290
3291     //SCIM_TRANS_CMD_START_HELPER
3292     void socket_start_helper (int client_id, uint32 context, String uuid) {
3293         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_start_helper ()\n";
3294         HelperClientIndex::iterator it = m_helper_client_index.find (uuid);
3295         lock ();
3296         uint32 ic = get_helper_ic (m_panel_client_map[client_id], context);
3297         String ic_uuid;
3298         /* Get the context uuid from the client context registration table. */
3299         {
3300             ClientContextUUIDRepository::iterator it = m_client_context_uuids.find (get_helper_ic (m_panel_client_map[client_id], context));
3301
3302             if (it != m_client_context_uuids.end ())
3303                 ic_uuid = it->second;
3304         }
3305
3306         if (m_current_socket_client == m_panel_client_map[client_id] && m_current_client_context == context) {
3307             if (!ic_uuid.length ()) ic_uuid = m_current_context_uuid;
3308         } else if (m_last_socket_client == m_panel_client_map[client_id] && m_last_client_context == context) {
3309             if (!ic_uuid.length ()) ic_uuid = m_last_context_uuid;
3310         }
3311
3312         if (it == m_helper_client_index.end ()) {
3313             SCIM_DEBUG_MAIN (5) << "Run this Helper.\n";
3314             m_start_helper_ic_index [uuid].push_back (std::make_pair (ic, ic_uuid));
3315             m_signal_run_helper (uuid, m_config_name, m_display_name);
3316         } else {
3317             SCIM_DEBUG_MAIN (5) << "Increase the Reference count.\n";
3318             m_panel_agent_manager.socket_start_helper (it->second.id, ic, ic_uuid);
3319             ++ it->second.ref;
3320         }
3321
3322         unlock ();
3323     }
3324     //SCIM_TRANS_CMD_STOP_HELPER
3325     void socket_stop_helper (int client_id, uint32 context, String uuid) {
3326         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_stop_helper ()\n";
3327         HelperClientIndex::iterator it = m_helper_client_index.find (uuid);
3328         lock ();
3329         uint32 ic = get_helper_ic (m_panel_client_map[client_id], context);
3330
3331         if (it != m_helper_client_index.end ()) {
3332             SCIM_DEBUG_MAIN (5) << "Decrase the Reference count.\n";
3333             -- it->second.ref;
3334             String ic_uuid;
3335             /* Get the context uuid from the client context registration table. */
3336             {
3337                 ClientContextUUIDRepository::iterator it = m_client_context_uuids.find (get_helper_ic (m_panel_client_map[client_id], context));
3338
3339                 if (it != m_client_context_uuids.end ())
3340                     ic_uuid = it->second;
3341             }
3342
3343             if (m_current_socket_client == m_panel_client_map[client_id] && m_current_client_context == context) {
3344                 if (!ic_uuid.length ()) ic_uuid = m_current_context_uuid;
3345             } else if (m_last_socket_client == m_panel_client_map[client_id] && m_last_client_context == context) {
3346                 if (!ic_uuid.length ()) ic_uuid = m_last_context_uuid;
3347             }
3348
3349             m_panel_agent_manager.helper_detach_input_context (it->second.id, ic, ic_uuid);
3350
3351             if (it->second.ref <= 0)
3352                 m_panel_agent_manager.exit (it->second.id, ic);
3353         }
3354
3355         unlock ();
3356     }
3357     //SCIM_TRANS_CMD_SEND_HELPER_EVENT
3358     void socket_send_helper_event (int client_id, uint32 context, String uuid, const Transaction& _nest_trans) {
3359         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_send_helper_event ()\n";
3360         HelperClientIndex::iterator it = m_helper_client_index.find (uuid);
3361
3362         if (it != m_helper_client_index.end ()) {
3363             String ic_uuid;
3364             /* Get the context uuid from the client context registration table. */
3365             {
3366                 ClientContextUUIDRepository::iterator it = m_client_context_uuids.find (get_helper_ic (m_panel_client_map[client_id], context));
3367
3368                 if (it != m_client_context_uuids.end ())
3369                     ic_uuid = it->second;
3370             }
3371
3372             if (m_current_socket_client == m_panel_client_map[client_id] && m_current_client_context == context) {
3373                 if (!ic_uuid.length ()) ic_uuid = m_current_context_uuid;
3374             } else if (m_last_socket_client == m_panel_client_map[client_id] && m_last_client_context == context) {
3375                 if (!ic_uuid.length ()) ic_uuid = m_last_context_uuid;
3376             }
3377
3378             m_panel_agent_manager.helper_process_imengine_event (it->second.id, get_helper_ic (m_panel_client_map[client_id], context), ic_uuid, _nest_trans);
3379         }
3380     }
3381
3382     //SCIM_TRANS_CMD_REGISTER_PROPERTIES
3383     void socket_helper_register_properties (int client, PropertyList& properties) {
3384         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_register_properties (" << client << ")\n";
3385         m_signal_register_helper_properties (client, properties);
3386
3387 #if 0 //why? remove if useless, infinite loop
3388         /* Check whether application is already focus_in */
3389         if (m_current_socket_client != -1) {
3390             SCIM_DEBUG_MAIN (2) << "Application is already focus_in!\n";
3391             focus_in_helper (m_current_helper_uuid, m_current_socket_client, m_current_client_context);
3392             reset_keyboard_ise ();
3393         }
3394
3395         /* Check whether ISE panel is already shown */
3396         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode && m_ise_context_length > 0) {
3397             SCIM_DEBUG_MAIN (2) << "Re-show ISE panel!\n";
3398             int    focused_client;
3399             uint32 focused_context;
3400             get_focused_context (focused_client, focused_context);
3401
3402             if (focused_client == -1 && m_active_client_id != -1) {
3403                 focused_client  = m_panel_client_map[m_active_client_id];
3404                 focused_context = 0;
3405             }
3406
3407             uint32 ctx = get_helper_ic (focused_client, focused_context);
3408             bool ret = show_helper (m_current_helper_uuid, m_ise_context_buffer, m_ise_context_length, ctx);
3409
3410             if (ret)
3411                 m_signal_show_ise ();
3412         }
3413 #endif
3414     }
3415     //SCIM_TRANS_CMD_UPDATE_PROPERTY
3416     void socket_helper_update_property (int client, Property& property) {
3417         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_update_property (" << client << ")\n";
3418         m_signal_update_helper_property (client, property);
3419     }
3420     //SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT
3421     void socket_helper_send_imengine_event (int client, uint32 target_ic, String target_uuid , Transaction& nest_trans) {
3422         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_send_imengine_event (" << client << ")\n";
3423         HelperInfoRepository::iterator hiit = m_helper_active_info_repository.find (client);
3424
3425         if (hiit != m_helper_active_info_repository.end ()) {
3426             int     target_client;
3427             uint32  target_context;
3428             get_imengine_client_context (target_ic, target_client, target_context);
3429             int     focused_client;
3430             uint32  focused_context;
3431             String  focused_uuid;
3432             focused_uuid = get_focused_context (focused_client, focused_context);
3433
3434             if (target_ic == (uint32) (-1)) {
3435                 target_client  = focused_client;
3436                 target_context = focused_context;
3437             }
3438
3439             if (target_uuid.length () == 0)
3440                 target_uuid = focused_uuid;
3441
3442             ClientInfo  client_info = socket_get_client_info (target_client);
3443             SCIM_DEBUG_MAIN (5) << "Target UUID = " << target_uuid << "  Focused UUId = " << focused_uuid << "\nTarget Client = " << target_client << "\n";
3444
3445             if (client_info.type == FRONTEND_CLIENT) {
3446                 /* If the original context value is greater than 0x7FFF, the line below would not work properly
3447                    since the target_context acquired by get_imengnie_client_context() is always smaller than 0x7FFF.
3448                    But since the send_imengine_event() of scim_helper module will call IMEngine's
3449                    process_helper_event() function directly, instead of sending SEND_IMENGINE_EVENT message.
3450                    So we are not going to handle this kind of exceptional case for now. */
3451                 m_panel_agent_manager.process_helper_event (target_client, target_context, target_uuid, hiit->second.uuid, nest_trans);
3452             }
3453         }
3454     }
3455
3456     void socket_helper_key_event_op (int client, int cmd, uint32 target_ic, String& target_uuid, KeyEvent& key) {
3457         if (!key.empty ()) {
3458             int     target_client;
3459             uint32  target_context;
3460             get_imengine_client_context (target_ic, target_client, target_context);
3461             int     focused_client;
3462             uint32  focused_context;
3463             String  focused_uuid;
3464             focused_uuid = get_focused_context (focused_client, focused_context);
3465
3466             if (target_ic == (uint32) (-1)) {
3467                 target_client  = focused_client;
3468                 target_context = focused_context;
3469             }
3470
3471             if (target_uuid.length () == 0)
3472                 target_uuid = focused_uuid;
3473
3474             if (target_client == -1) {
3475                 /* FIXUP: monitor 'Invalid Window' error */
3476                 LOGW ("focused target client is NULL");
3477             } else if (target_uuid == focused_uuid &&
3478                 clients_equal (target_client, focused_client) &&
3479                 contexts_equal (target_context, focused_context)) {
3480                 ClientInfo client_info = socket_get_client_info (focused_client);
3481
3482                 if (client_info.type == FRONTEND_CLIENT) {
3483                     m_panel_agent_manager.socket_helper_key_event (focused_client, focused_context, cmd, key);
3484                 }
3485             } else {
3486                 LOGD ("[target_client : %d, focused_client : %d] => %d, [target_context : %u, focused_context : %u] => %d",
3487                     target_client, focused_client, clients_equal (target_client, focused_client),
3488                     target_context, focused_context, contexts_equal (target_context, focused_context));
3489             }
3490         }
3491     }
3492     //SCIM_TRANS_CMD_PROCESS_KEY_EVENT
3493     //SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT
3494     void socket_helper_send_key_event (int client, uint32 target_ic, String target_uuid, KeyEvent key) {
3495         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_send_key_event (" << client << ")\n";
3496         ISF_PROF_DEBUG ("first message")
3497         socket_helper_key_event_op (client, SCIM_TRANS_CMD_PROCESS_KEY_EVENT, target_ic, target_uuid, key);
3498     }
3499     //SCIM_TRANS_CMD_FORWARD_KEY_EVENT
3500     void socket_helper_forward_key_event (int client, uint32 target_ic, String target_uuid, KeyEvent key) {
3501         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_forward_key_event (" << client << ")\n";
3502         socket_helper_key_event_op (client, SCIM_TRANS_CMD_FORWARD_KEY_EVENT, target_ic, target_uuid, key);
3503     }
3504
3505     //SCIM_TRANS_CMD_COMMIT_STRING
3506     void socket_helper_commit_string (int client, uint32 target_ic, String target_uuid, WideString wstr) {
3507         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_commit_string (" << client << ")\n";
3508
3509         if (wstr.length ()) {
3510             int     target_client;
3511             uint32  target_context;
3512             get_imengine_client_context (target_ic, target_client, target_context);
3513             int     focused_client;
3514             uint32  focused_context;
3515             String  focused_uuid;
3516             focused_uuid = get_focused_context (focused_client, focused_context);
3517
3518             if (target_ic == (uint32) (-1)) {
3519                 target_client  = focused_client;
3520                 target_context = focused_context;
3521             }
3522
3523             if (target_uuid.length () == 0)
3524                 target_uuid = focused_uuid;
3525
3526             if (target_uuid == focused_uuid &&
3527                 clients_equal (target_client, focused_client) &&
3528                 contexts_equal (target_context, focused_context)) {
3529                 ClientInfo client_info = socket_get_client_info (focused_client);
3530
3531                 if (client_info.type == FRONTEND_CLIENT) {
3532                     m_panel_agent_manager.commit_string (focused_client, focused_context, wstr);
3533                 } else {
3534                     std::cerr << "target client is not existed!!!" << "\n";
3535                 }
3536             }
3537         }
3538     }
3539     //SCIM_TRANS_CMD_GET_SURROUNDING_TEXT
3540     void socket_helper_get_surrounding_text (int client, String uuid, uint32 maxlen_before, uint32 maxlen_after) {
3541         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << " (" << client << ")\n";
3542         int     focused_client;
3543         uint32  focused_context;
3544         get_focused_context (focused_client, focused_context);
3545         ClientInfo client_info = socket_get_client_info (focused_client);
3546
3547         /* If the get_surrounding_text was received when there is no client available,
3548          * return empty surrounding text since the sender would be waiting for reply */
3549         if (focused_client == -1) {
3550             socket_update_surrounding_text("", 0);
3551         } else {
3552             if (client_info.type == FRONTEND_CLIENT) {
3553                 m_panel_agent_manager.socket_helper_get_surrounding_text (focused_client, focused_context, maxlen_before, maxlen_after);
3554             }
3555         }
3556     }
3557     //SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT
3558     void socket_helper_delete_surrounding_text (int client, uint32 offset, uint32 len) {
3559         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << " (" << client << ")\n";
3560         int     focused_client;
3561         uint32  focused_context;
3562         get_focused_context (focused_client, focused_context);
3563         ClientInfo client_info = socket_get_client_info (focused_client);
3564
3565         if (client_info.type == FRONTEND_CLIENT) {
3566             m_panel_agent_manager.socket_helper_delete_surrounding_text (focused_client, focused_context, offset, len);
3567         }
3568     }
3569     //SCIM_TRANS_CMD_GET_SELECTION
3570     void socket_helper_get_selection (int client, String uuid) {
3571         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << " (" << client << ")\n";
3572         int     focused_client;
3573         uint32  focused_context;
3574         get_focused_context (focused_client, focused_context);
3575         ClientInfo client_info = socket_get_client_info (focused_client);
3576
3577         if (client_info.type == FRONTEND_CLIENT) {
3578             m_panel_agent_manager.socket_helper_get_selection (focused_client, focused_context);
3579         }
3580     }
3581     //SCIM_TRANS_CMD_SET_SELECTION
3582     void socket_helper_set_selection (int client, uint32 start, uint32 end) {
3583         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << " (" << client << ")\n";
3584         int     focused_client;
3585         uint32  focused_context;
3586         get_focused_context (focused_client, focused_context);
3587         ClientInfo client_info = socket_get_client_info (focused_client);
3588
3589         if (client_info.type == FRONTEND_CLIENT) {
3590             m_panel_agent_manager.socket_helper_set_selection (focused_client, focused_context, start, end);
3591         }
3592     }
3593
3594     //SCIM_TRANS_CMD_SHOW_PREEDIT_STRING
3595     void socket_helper_show_preedit_string (int client, uint32 target_ic, String target_uuid) {
3596         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_show_preedit_string (" << client << ")\n";
3597         int     target_client;
3598         uint32  target_context;
3599         get_imengine_client_context (target_ic, target_client, target_context);
3600         int     focused_client;
3601         uint32  focused_context;
3602         String  focused_uuid = get_focused_context (focused_client, focused_context);
3603
3604         if (target_ic == (uint32) (-1)) {
3605             target_client  = focused_client;
3606             target_context = focused_context;
3607         }
3608
3609         if (target_uuid.length () == 0)
3610             target_uuid = focused_uuid;
3611
3612         if (target_uuid == focused_uuid &&
3613             clients_equal (target_client, focused_client) &&
3614             contexts_equal (target_context, focused_context)) {
3615             ClientInfo client_info = socket_get_client_info (focused_client);
3616
3617             if (client_info.type == FRONTEND_CLIENT) {
3618                 m_panel_agent_manager.show_preedit_string (focused_client, focused_context);
3619             }
3620         }
3621     }
3622     //SCIM_TRANS_CMD_HIDE_PREEDIT_STRING
3623     void socket_helper_hide_preedit_string (int client, uint32 target_ic, String target_uuid) {
3624         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_hide_preedit_string (" << client << ")\n";
3625         int     target_client;
3626         uint32  target_context;
3627         get_imengine_client_context (target_ic, target_client, target_context);
3628         int     focused_client;
3629         uint32  focused_context;
3630         String  focused_uuid = get_focused_context (focused_client, focused_context);
3631
3632         if (target_ic == (uint32) (-1)) {
3633             target_client  = focused_client;
3634             target_context = focused_context;
3635         }
3636
3637         if (target_uuid.length () == 0)
3638             target_uuid = focused_uuid;
3639
3640         if (target_uuid == focused_uuid &&
3641             clients_equal (target_client, focused_client) &&
3642             contexts_equal (target_context, focused_context)) {
3643             ClientInfo client_info = socket_get_client_info (focused_client);
3644
3645             if (client_info.type == FRONTEND_CLIENT) {
3646                 m_panel_agent_manager.hide_preedit_string (focused_client, focused_context);
3647             }
3648         }
3649     }
3650     //SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING
3651     void socket_helper_update_preedit_string (int client, uint32 target_ic, String target_uuid, WideString preedit, WideString commit, AttributeList& attrs, uint32 caret) {
3652         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_update_preedit_string (" << client << ")\n";
3653         int     target_client;
3654         uint32  target_context;
3655         get_imengine_client_context (target_ic, target_client, target_context);
3656         int     focused_client;
3657         uint32  focused_context;
3658         String  focused_uuid;
3659         focused_uuid = get_focused_context (focused_client, focused_context);
3660
3661         if (target_ic == (uint32) (-1)) {
3662             target_client  = focused_client;
3663             target_context = focused_context;
3664         }
3665
3666         if (target_uuid.length () == 0)
3667             target_uuid = focused_uuid;
3668
3669         if (target_uuid == focused_uuid &&
3670             clients_equal (target_client, focused_client) &&
3671             contexts_equal (target_context, focused_context)) {
3672             ClientInfo client_info = socket_get_client_info (focused_client);
3673
3674             if (client_info.type == FRONTEND_CLIENT) {
3675                 m_panel_agent_manager.update_preedit_string (focused_client, focused_context, preedit, commit, attrs, caret);
3676             }
3677         }
3678     }
3679     //SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET
3680     void socket_helper_update_preedit_caret (int client, uint32 caret) {
3681         SCIM_DEBUG_MAIN (4) << __func__ << " (" << client << ")\n";
3682         int     focused_client;
3683         uint32  focused_context;
3684         String  focused_uuid;
3685         focused_uuid = get_focused_context (focused_client, focused_context);
3686         ClientInfo client_info = socket_get_client_info (focused_client);
3687
3688         if (client_info.type == FRONTEND_CLIENT) {
3689             m_panel_agent_manager.update_preedit_caret (focused_client, focused_context, caret);
3690         }
3691     }
3692
3693     //ISM_TRANS_CMD_RECAPTURE_STRING
3694     void socket_helper_recapture_string (int client, uint32 target_ic, String target_uuid, int offset, int len, WideString preedit,
3695             WideString commit, AttributeList& attrs) {
3696         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_recapture_string (" << client << ")\n";
3697         int     target_client;
3698         uint32  target_context;
3699         get_imengine_client_context (target_ic, target_client, target_context);
3700         int     focused_client;
3701         uint32  focused_context;
3702         String  focused_uuid;
3703         focused_uuid = get_focused_context (focused_client, focused_context);
3704
3705         if (target_ic == (uint32) (-1)) {
3706             target_client  = focused_client;
3707             target_context = focused_context;
3708         }
3709
3710         if (target_uuid.length () == 0)
3711             target_uuid = focused_uuid;
3712
3713         if (target_uuid == focused_uuid &&
3714             clients_equal (target_client, focused_client) &&
3715             contexts_equal (target_context, focused_context)) {
3716             ClientInfo client_info = socket_get_client_info (focused_client);
3717
3718             if (client_info.type == FRONTEND_CLIENT) {
3719                 m_panel_agent_manager.recapture_string (focused_client, focused_context, offset, len, preedit, commit, attrs);
3720             }
3721         }
3722     }
3723
3724     //SCIM_TRANS_CMD_PANEL_REGISTER_HELPER
3725     void socket_helper_register_helper (int client, HelperInfo& info) {
3726         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_register_helper (" << client << ")\n";
3727         bool result = false;
3728         lock ();
3729         String language;
3730         int type;
3731         int option;
3732         String module_name;
3733
3734         if (!m_signal_get_ise_information (info.uuid, info.name, language, type, option, module_name)) {
3735             LOGW ("This helper (%s) is not IME", info.uuid.c_str ());
3736             unlock ();
3737             return;
3738         }
3739         info.option = option;
3740
3741         if (info.uuid.length ()) {
3742             SCIM_DEBUG_MAIN (4) << "New Helper uuid=" << info.uuid << " name=" << info.name << "\n";
3743             HelperClientIndex::iterator it = m_helper_client_index.find (info.uuid);
3744
3745             if (it == m_helper_client_index.end ()) {
3746                 m_helper_info_repository [client] = info;
3747                 m_helper_client_index [info.uuid] = HelperClientStub (client, 1);
3748                 StartHelperICIndex::iterator icit = m_start_helper_ic_index.find (info.uuid);
3749
3750                 if (icit != m_start_helper_ic_index.end ()) {
3751                     m_panel_agent_manager.helper_attach_input_context_and_update_screen (client, icit->second, m_current_screen);
3752                     m_start_helper_ic_index.erase (icit);
3753                     result = true;
3754                 } else {
3755                     LOGW ("Failed to register IME : %s", info.uuid.c_str ());
3756                     m_panel_agent_manager.send_fail_reply(client);
3757                 }
3758             } else {
3759                 LOGW ("Failed to register IME : %s", info.uuid.c_str ());
3760                 m_panel_agent_manager.send_fail_reply(client);
3761             }
3762         }
3763
3764         unlock ();
3765
3766         if (result) {
3767             LOGD ("Succeed to regster IME : %s", info.uuid.c_str ());
3768             m_signal_register_helper (client, info);
3769         }
3770     }
3771
3772     //SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER
3773     void socket_helper_register_helper_passive (int client, HelperInfo& info) {
3774         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_register_helper_passive (" << client << ")\n";
3775         lock ();
3776         String language;
3777         int type;
3778         int option;
3779         String module_name;
3780
3781         if (!m_signal_get_ise_information (info.uuid, info.name, language, type, option, module_name)) {
3782             LOGW ("This helper (%s) is not IME", info.uuid.c_str ());
3783             unlock ();
3784             return;
3785         }
3786         info.option = option;
3787
3788         if (info.uuid.length ()) {
3789             SCIM_DEBUG_MAIN (4) << "New Helper Passive uuid=" << info.uuid << " name=" << info.name << "\n";
3790             HelperInfoRepository::iterator it = m_helper_active_info_repository.find (client);
3791
3792             if (it == m_helper_active_info_repository.end ()) {
3793                 m_helper_active_info_repository[client] =  info;
3794             }
3795
3796             StringIntRepository::iterator iter = m_ise_pending_repository.find (info.uuid);
3797
3798             if (iter != m_ise_pending_repository.end ()) {
3799                 m_ise_pending_repository.erase (iter);
3800             }
3801
3802             iter = m_ise_pending_repository.find (info.name);
3803
3804             if (iter != m_ise_pending_repository.end ()) {
3805                 m_ise_pending_repository.erase (iter);
3806             }
3807         }
3808
3809         unlock ();
3810     }
3811     //ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT
3812     void socket_helper_update_input_context (int client, uint32 type, uint32 value) {
3813         SCIM_DEBUG_MAIN (4) << "InfoManager::socket_helper_update_input_context (" << client << ")\n";
3814         m_signal_update_input_context ((int)type, (int)value);
3815         int    focused_client;
3816         uint32 focused_context;
3817         get_focused_context (focused_client, focused_context);
3818         ClientInfo client_info = socket_get_client_info (focused_client);
3819
3820         if (client_info.type == FRONTEND_CLIENT) {
3821             m_panel_agent_manager.update_ise_input_context (focused_client, focused_context, type, value);
3822         } else {
3823             std::cerr << "focused client is not existed!!!" << "\n";
3824         }
3825     }
3826     //ISM_TRANS_CMD_UPDATE_ISE_LANGUAGE_LOCALE
3827     void socket_helper_update_language_locale(int client, String locale) {
3828         SCIM_DEBUG_MAIN(4) << "InfoManager::socket_helper_update_language_locale (" << client << ")\n";
3829         m_signal_update_language_locale(locale);
3830
3831         int    focused_client;
3832         uint32 focused_context;
3833         get_focused_context(focused_client, focused_context);
3834         ClientInfo client_info = socket_get_client_info(focused_client);
3835
3836         if (client_info.type == FRONTEND_CLIENT) {
3837             m_panel_agent_manager.update_ise_language_locale(focused_client, focused_context, locale);
3838         } else {
3839             std::cerr << "focused client is not existed!!!" << "\n";
3840         }
3841     }
3842     //SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND
3843     void socket_helper_send_private_command (int client, String command) {
3844         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << " (" << client << ")\n";
3845         int     focused_client;
3846         uint32  focused_context;
3847         get_focused_context (focused_client, focused_context);
3848         ClientInfo client_info = socket_get_client_info (focused_client);
3849
3850         if (client_info.type == FRONTEND_CLIENT) {
3851             m_panel_agent_manager.send_private_command (focused_client, focused_context, command);
3852         }
3853     }
3854     //SCIM_TRANS_CMD_COMMIT_CONTENT
3855     void socket_helper_commit_content (int client, String content, String description, String mime_types) {
3856         SCIM_DEBUG_MAIN (4) << __FUNCTION__ << " (" << client << ")\n";
3857         int     focused_client;
3858         uint32  focused_context;
3859         get_focused_context (focused_client, focused_context);
3860         ClientInfo client_info = socket_get_client_info (focused_client);
3861
3862         if (client_info.type == FRONTEND_CLIENT) {
3863             m_panel_agent_manager.commit_content (focused_client, focused_context, content, description, mime_types);
3864         }
3865     }
3866     //ISM_TRANS_CMD_UPDATE_ISE_EXIT
3867     //void UPDATE_ISE_EXIT (int client) {
3868     //    LOGD ("");
3869     //    HelperInfoRepository::iterator hiit = m_helper_active_info_repository.find (client);
3870
3871     //    if (hiit != m_helper_active_info_repository.end ()) {
3872     //        String l_uuid = hiit->second.uuid;
3873     //        HelperClientIndex::iterator it = m_helper_client_index.find (l_uuid);
3874
3875     //        if (it != m_helper_client_index.end ()) {
3876     //            del_client (it->second.id);
3877     //        }
3878     //    }
3879
3880     //    del_client (client);
3881     //}
3882
3883     void process_key_event_done (KeyEvent &key, uint32 ret, uint32 serial) {
3884         int     focused_client;
3885         uint32  focused_context;
3886         get_focused_context (focused_client, focused_context);
3887         ClientInfo client_info = socket_get_client_info (focused_client);
3888
3889         if (client_info.type == FRONTEND_CLIENT) {
3890             m_panel_agent_manager.process_key_event_done (focused_client, focused_context, key, ret, serial);
3891         }
3892     }
3893
3894     //ISM_TRANS_CMD_REQUEST_ISE_HIDE
3895     void request_ise_hide () {
3896         int     focused_client;
3897         uint32  focused_context;
3898         get_focused_context (focused_client, focused_context);
3899         ClientInfo client_info = socket_get_client_info (focused_client);
3900
3901         if (client_info.type == FRONTEND_CLIENT) {
3902             m_panel_agent_manager.request_ise_hide (focused_client, focused_context);
3903         }
3904     }
3905
3906     void socket_reset_helper_input_context (const String& uuid, int client, uint32 context) {
3907         HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
3908
3909         if (it != m_helper_client_index.end ()) {
3910             uint32 ctx = get_helper_ic (client, context);
3911             m_panel_agent_manager.reset_helper_context (it->second.id, ctx, uuid);
3912         }
3913     }
3914
3915     bool helper_select_aux (uint32 item) {
3916         SCIM_DEBUG_MAIN (4) << "InfoManager::helper_select_aux \n";
3917
3918         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
3919             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
3920
3921             if (it != m_helper_client_index.end ()) {
3922                 int    client;
3923                 uint32 context;
3924                 uint32 ctx;
3925                 get_focused_context (client, context);
3926                 ctx = get_helper_ic (client, context);
3927                 m_panel_agent_manager.select_aux (it->second.id, ctx, item);
3928                 return true;
3929             }
3930         }
3931
3932         return false;
3933     }
3934
3935     bool helper_select_candidate (uint32 item) {
3936         SCIM_DEBUG_MAIN (4) << "InfoManager::helper_select_candidate \n";
3937
3938         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
3939             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
3940
3941             if (it != m_helper_client_index.end ()) {
3942                 int    client;
3943                 uint32 context;
3944                 uint32 ctx;
3945                 get_focused_context (client, context);
3946                 ctx = get_helper_ic (client, context);
3947                 m_panel_agent_manager.select_candidate (it->second.id, ctx, item);
3948                 return true;
3949             }
3950         }
3951
3952         return false;
3953     }
3954
3955     bool helper_lookup_table_page_up (void) {
3956         SCIM_DEBUG_MAIN (4) << "InfoManager::helper_lookup_table_page_up \n";
3957
3958         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
3959             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
3960
3961             if (it != m_helper_client_index.end ()) {
3962                 int    client;
3963                 uint32 context;
3964                 uint32 ctx;
3965                 get_focused_context (client, context);
3966                 ctx = get_helper_ic (client, context);
3967                 m_panel_agent_manager.lookup_table_page_up (it->second.id, ctx);
3968                 return true;
3969             }
3970         }
3971
3972         return false;
3973     }
3974
3975     bool helper_lookup_table_page_down (void) {
3976         SCIM_DEBUG_MAIN (4) << "InfoManager::helper_lookup_table_page_down \n";
3977
3978         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
3979             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
3980
3981             if (it != m_helper_client_index.end ()) {
3982                 int    client;
3983                 uint32 context;
3984                 uint32 ctx;
3985                 get_focused_context (client, context);
3986                 ctx = get_helper_ic (client, context);
3987                 m_panel_agent_manager.lookup_table_page_down (it->second.id, ctx);
3988                 return true;
3989             }
3990         }
3991
3992         return false;
3993     }
3994
3995     bool helper_update_lookup_table_page_size (uint32 size) {
3996         SCIM_DEBUG_MAIN (4) << "InfoManager::helper_update_lookup_table_page_size \n";
3997
3998         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
3999             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4000
4001             if (it != m_helper_client_index.end ()) {
4002                 int    client;
4003                 uint32 context;
4004                 uint32 ctx;
4005                 get_focused_context (client, context);
4006                 ctx = get_helper_ic (client, context);
4007                 m_panel_agent_manager.update_lookup_table_page_size (it->second.id, ctx, size);
4008                 return true;
4009             }
4010         }
4011
4012         return false;
4013     }
4014
4015     bool helper_update_candidate_item_layout (const std::vector<uint32>& row_items) {
4016         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
4017
4018         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
4019             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4020
4021             if (it != m_helper_client_index.end ()) {
4022                 int    client;
4023                 uint32 context;
4024                 uint32 ctx;
4025                 get_focused_context (client, context);
4026                 ctx = get_helper_ic (client, context);
4027                 m_panel_agent_manager.update_candidate_item_layout (it->second.id, ctx, row_items);
4028                 return true;
4029             }
4030         }
4031
4032         return false;
4033     }
4034
4035     bool helper_select_associate (uint32 item) {
4036         SCIM_DEBUG_MAIN (4) << "InfoManager::helper_select_associate \n";
4037
4038         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
4039             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4040
4041             if (it != m_helper_client_index.end ()) {
4042                 int    client;
4043                 uint32 context;
4044                 uint32 ctx;
4045                 get_focused_context (client, context);
4046                 ctx = get_helper_ic (client, context);
4047                 m_panel_agent_manager.select_associate (it->second.id, ctx, item);
4048                 return true;
4049             }
4050         }
4051
4052         return false;
4053     }
4054
4055     bool helper_associate_table_page_up (void) {
4056         SCIM_DEBUG_MAIN (4) << "InfoManager::helper_associate_table_page_up \n";
4057
4058         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
4059             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4060
4061             if (it != m_helper_client_index.end ()) {
4062                 int    client;
4063                 uint32 context;
4064                 uint32 ctx;
4065                 get_focused_context (client, context);
4066                 ctx = get_helper_ic (client, context);
4067                 m_panel_agent_manager.associate_table_page_up (it->second.id, ctx);
4068                 return true;
4069             }
4070         }
4071
4072         return false;
4073     }
4074
4075     bool helper_associate_table_page_down (void) {
4076         SCIM_DEBUG_MAIN (4) << "InfoManager::helper_associate_table_page_down \n";
4077
4078         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
4079             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4080
4081             if (it != m_helper_client_index.end ()) {
4082                 int    client;
4083                 uint32 context;
4084                 uint32 ctx;
4085                 get_focused_context (client, context);
4086                 ctx = get_helper_ic (client, context);
4087                 m_panel_agent_manager.associate_table_page_down (it->second.id, ctx);
4088                 return true;
4089             }
4090         }
4091
4092         return false;
4093     }
4094
4095     bool helper_update_associate_table_page_size (uint32         size) {
4096         SCIM_DEBUG_MAIN (4) << "InfoManager::helper_update_associate_table_page_size \n";
4097
4098         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
4099             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4100
4101             if (it != m_helper_client_index.end ()) {
4102                 int    client;
4103                 uint32 context;
4104                 uint32 ctx;
4105                 get_focused_context (client, context);
4106                 ctx = get_helper_ic (client, context);
4107                 m_panel_agent_manager.update_associate_table_page_size (it->second.id, ctx, size);
4108                 return true;
4109             }
4110         }
4111
4112         return false;
4113     }
4114
4115     bool helper_update_displayed_candidate_number (uint32 size) {
4116         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
4117
4118         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
4119             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4120
4121             if (it != m_helper_client_index.end ()) {
4122                 int    client;
4123                 uint32 context;
4124                 uint32 ctx;
4125                 get_focused_context (client, context);
4126                 ctx = get_helper_ic (client, context);
4127                 m_panel_agent_manager.update_displayed_candidate_number (it->second.id, ctx, size);
4128                 return true;
4129             }
4130         }
4131
4132         return false;
4133     }
4134
4135     bool helper_longpress_candidate (uint32 index) {
4136         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
4137
4138         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT) {
4139             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4140
4141             if (it != m_helper_client_index.end ()) {
4142                 int    client;
4143                 uint32 context;
4144                 uint32 ctx;
4145                 get_focused_context (client, context);
4146                 ctx = get_helper_ic (client, context);
4147                 m_panel_agent_manager.send_longpress_event (it->second.id, ctx, index);
4148                 return true;
4149             }
4150         }
4151
4152         std::cerr << __func__ << " is failed!!!\n";
4153         return false;
4154     }
4155
4156     void helper_all_update_spot_location (int x, int y) {
4157         SCIM_DEBUG_MAIN (5) << "InfoManager::helper_all_update_spot_location (" << x << "," << y << ")\n";
4158         HelperInfoRepository::iterator hiit = m_helper_info_repository.begin ();
4159         int    client;
4160         uint32 context;
4161         String uuid = get_focused_context (client, context);
4162
4163         for (; hiit != m_helper_info_repository.end (); ++ hiit) {
4164             if (hiit->second.option & SCIM_HELPER_NEED_SPOT_LOCATION_INFO) {
4165                 m_panel_agent_manager.helper_all_update_spot_location (hiit->first, get_helper_ic (client, context), uuid, x, y);
4166             }
4167         }
4168     }
4169
4170     void helper_all_update_cursor_position (int cursor_pos) {
4171         SCIM_DEBUG_MAIN (5) << "InfoManager::helper_all_update_cursor_position (" << cursor_pos << ")\n";
4172         HelperInfoRepository::iterator hiit = m_helper_info_repository.begin ();
4173         int    client;
4174         uint32 context;
4175         String uuid = get_focused_context (client, context);
4176
4177         for (; hiit != m_helper_info_repository.end (); ++ hiit) {
4178             m_panel_agent_manager.helper_all_update_cursor_position (hiit->first, get_helper_ic (client, context), uuid, cursor_pos);
4179         }
4180     }
4181
4182     void helper_all_update_screen (int screen) {
4183         SCIM_DEBUG_MAIN (5) << "InfoManager::helper_all_update_screen (" << screen << ")\n";
4184         HelperInfoRepository::iterator hiit = m_helper_info_repository.begin ();
4185         int    client;
4186         uint32 context;
4187         String uuid;
4188         uuid = get_focused_context (client, context);
4189
4190         for (; hiit != m_helper_info_repository.end (); ++ hiit) {
4191             if (hiit->second.option & SCIM_HELPER_NEED_SCREEN_INFO) {
4192                 m_panel_agent_manager.helper_all_update_screen (hiit->first, get_helper_ic (client, context), uuid, screen);
4193             }
4194         }
4195     }
4196
4197     bool set_autocapital_type (int mode) {
4198         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
4199
4200         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || (m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)) {
4201             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4202
4203             if (it != m_helper_client_index.end ()) {
4204                 int    client;
4205                 uint32 context;
4206                 uint32 ctx;
4207                 get_focused_context (client, context);
4208                 ctx = get_helper_ic (client, context);
4209                 m_panel_agent_manager.set_autocapital_type (it->second.id, ctx, m_current_helper_uuid, mode);
4210                 return true;
4211             }
4212         }
4213
4214         std::cerr << __func__ << " is failed!!!\n";
4215         return false;
4216     }
4217
4218     bool set_prediction_allow (int client, int mode) {
4219         SCIM_DEBUG_MAIN (4) << __func__ << "\n";
4220
4221         if (TOOLBAR_HELPER_MODE == m_current_toolbar_mode || (m_current_helper_option & ISM_HELPER_PROCESS_KEYBOARD_KEYEVENT)) {
4222             HelperClientIndex::iterator it = m_helper_client_index.find (m_current_helper_uuid);
4223
4224             if (it != m_helper_client_index.end ()) {
4225                 int    client;
4226                 uint32 context;
4227                 uint32 ctx;
4228                 get_focused_context (client, context);
4229                 ctx = get_helper_ic (client, context);
4230                 m_panel_agent_manager.set_prediction_allow (it->second.id, ctx, m_current_helper_uuid, mode);
4231                 return true;
4232             }
4233         }
4234
4235         std::cerr << __func__ << " is failed!!!\n";
4236         return false;
4237     }
4238
4239     const String& get_focused_context (int& client, uint32& context, bool force_last_context = false) const {
4240         if (m_current_socket_client >= 0) {
4241             client  = m_current_socket_client;
4242             context = m_current_client_context;
4243             return m_current_context_uuid;
4244         } else {
4245             client  = m_last_socket_client;
4246             context = m_last_client_context;
4247             return m_last_context_uuid;
4248         }
4249     }
4250
4251 private:
4252     void socket_transaction_start (void) {
4253         m_signal_transaction_start ();
4254     }
4255
4256     void socket_transaction_end (void) {
4257         m_signal_transaction_end ();
4258     }
4259
4260     void lock (void) {
4261         m_signal_lock ();
4262     }
4263     void unlock (void) {
4264         m_signal_unlock ();
4265     }
4266 };
4267
4268 InfoManager::InfoManager ()
4269     : m_impl (new InfoManagerImpl ())
4270 {
4271 }
4272
4273 InfoManager::~InfoManager ()
4274 {
4275     delete m_impl;
4276 }
4277
4278 bool
4279 InfoManager::initialize (InfoManager* info_manager, const ConfigPointer& config, const String& display, bool resident)
4280 {
4281     return m_impl->initialize (info_manager, config, display, resident);
4282 }
4283
4284 bool
4285 InfoManager::valid (void) const
4286 {
4287     return m_impl->valid ();
4288 }
4289
4290 void
4291 InfoManager::stop (void)
4292 {
4293     if (m_impl != NULL)
4294         m_impl->stop ();
4295 }
4296
4297 const ClientInfo&
4298 InfoManager::socket_get_client_info (int client) const
4299 {
4300     return m_impl->socket_get_client_info (client);
4301 }
4302
4303 void InfoManager::hide_helper (const String& uuid)
4304 {
4305     m_impl->hide_helper (uuid);
4306 }
4307 TOOLBAR_MODE_T
4308 InfoManager::get_current_toolbar_mode () const
4309 {
4310     return m_impl->get_current_toolbar_mode ();
4311 }
4312
4313 void
4314 InfoManager::get_current_ise_geometry (rectinfo& rect)
4315 {
4316     m_impl->get_current_ise_geometry (rect);
4317 }
4318
4319 String
4320 InfoManager::get_current_helper_uuid () const
4321 {
4322     return m_impl->get_current_helper_uuid ();
4323 }
4324
4325 String
4326 InfoManager::get_current_ise_name () const
4327 {
4328     return m_impl->get_current_ise_name ();
4329 }
4330
4331 void
4332 InfoManager::set_current_toolbar_mode (TOOLBAR_MODE_T mode)
4333 {
4334     m_impl->set_current_toolbar_mode (mode);
4335 }
4336
4337 void
4338 InfoManager::set_current_ise_name (String& name)
4339 {
4340     m_impl->set_current_ise_name (name);
4341 }
4342
4343 void
4344 InfoManager::set_current_helper_option (uint32 option)
4345 {
4346     m_impl->set_current_helper_option (option);
4347 }
4348
4349 void
4350 InfoManager::update_candidate_panel_event (uint32 nType, uint32 nValue)
4351 {
4352     m_impl->update_panel_event (ISM_TRANS_CMD_UPDATE_ISF_CANDIDATE_PANEL, nType, nValue);
4353 }
4354
4355 void
4356 InfoManager::update_input_panel_event (uint32 nType, uint32 nValue)
4357 {
4358     m_impl->update_panel_event (ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT, nType, nValue);
4359 }
4360
4361 bool
4362 InfoManager::move_preedit_caret (uint32         position)
4363 {
4364     return m_impl->move_preedit_caret (position);
4365 }
4366
4367 //useless
4368 #if 0
4369 bool
4370 InfoManager::request_help (void)
4371 {
4372     return m_impl->request_help ();
4373 }
4374
4375 bool
4376 InfoManager::request_factory_menu (void)
4377 {
4378     return m_impl->request_factory_menu ();
4379 }
4380 #endif
4381
4382 bool
4383 InfoManager::change_factory (const String&  uuid)
4384 {
4385     return m_impl->change_factory (uuid);
4386 }
4387
4388 bool
4389 InfoManager::helper_candidate_show (void)
4390 {
4391     return m_impl->helper_candidate_show ();
4392 }
4393
4394 bool
4395 InfoManager::helper_candidate_hide (void)
4396 {
4397     return m_impl->helper_candidate_hide ();
4398 }
4399
4400 bool
4401 InfoManager::candidate_more_window_show (void)
4402 {
4403     return m_impl->candidate_more_window_show ();
4404 }
4405
4406 bool
4407 InfoManager::candidate_more_window_hide (void)
4408 {
4409     return m_impl->candidate_more_window_hide ();
4410 }
4411
4412 bool
4413 InfoManager::update_helper_lookup_table (const LookupTable& table)
4414 {
4415     return m_impl->update_helper_lookup_table (table);
4416 }
4417
4418 bool
4419 InfoManager::select_aux (uint32         item)
4420 {
4421     return m_impl->select_aux (item);
4422 }
4423
4424 bool
4425 InfoManager::select_candidate (uint32         item)
4426 {
4427     return m_impl->select_candidate (item);
4428 }
4429
4430 bool
4431 InfoManager::lookup_table_page_up (void)
4432 {
4433     return m_impl->lookup_table_page_up ();
4434 }
4435
4436 bool
4437 InfoManager::lookup_table_page_down (void)
4438 {
4439     return m_impl->lookup_table_page_down ();
4440 }
4441
4442 bool
4443 InfoManager::update_lookup_table_page_size (uint32         size)
4444 {
4445     return m_impl->update_lookup_table_page_size (size);
4446 }
4447
4448 bool
4449 InfoManager::update_candidate_item_layout (const std::vector<uint32>& row_items)
4450 {
4451     return m_impl->update_candidate_item_layout (row_items);
4452 }
4453
4454 bool
4455 InfoManager::select_associate (uint32         item)
4456 {
4457     return m_impl->select_associate (item);
4458 }
4459
4460 bool
4461 InfoManager::associate_table_page_up (void)
4462 {
4463     return m_impl->associate_table_page_up ();
4464 }
4465
4466 bool
4467 InfoManager::associate_table_page_down (void)
4468 {
4469     return m_impl->associate_table_page_down ();
4470 }
4471
4472 bool
4473 InfoManager::update_associate_table_page_size (uint32         size)
4474 {
4475     return m_impl->update_associate_table_page_size (size);
4476 }
4477
4478 bool
4479 InfoManager::update_displayed_candidate_number (uint32        size)
4480 {
4481     return m_impl->update_displayed_candidate_number (size);
4482 }
4483
4484 void
4485 InfoManager::send_longpress_event (int type, int index)
4486 {
4487     m_impl->send_longpress_event (type, index);
4488 }
4489
4490 bool
4491 InfoManager::trigger_property (const String&  property)
4492 {
4493     return m_impl->trigger_property (property);
4494 }
4495
4496 bool
4497 InfoManager::start_helper (const String&  uuid)
4498 {
4499     return m_impl->start_helper (uuid, -2, 0);
4500 }
4501
4502 bool
4503 InfoManager::stop_helper (const String&  uuid)
4504 {
4505     return m_impl->stop_helper (uuid, -2, 0);
4506 }
4507
4508 void
4509 InfoManager::set_default_ise (const DEFAULT_ISE_T&  ise)
4510 {
4511     m_impl->set_default_ise (ise);
4512 }
4513
4514 void
4515 InfoManager::set_should_shared_ise (const bool should_shared_ise)
4516 {
4517     m_impl->set_should_shared_ise (should_shared_ise);
4518 }
4519
4520 //void
4521 //InfoManager::reload_config                  (void)
4522 //{
4523 //    m_impl->reload_config ();
4524 //}
4525
4526 bool
4527 InfoManager::exit (void)
4528 {
4529     return m_impl->exit ();
4530 }
4531 void
4532 InfoManager::update_ise_list (std::vector<String>& strList)
4533 {
4534     m_impl->update_ise_list (strList);
4535 }
4536
4537 bool
4538 InfoManager::remoteinput_update_preedit_string (WideString str, AttributeList &attrs, uint32 caret)
4539 {
4540     return m_impl->remoteinput_update_preedit_string (str, attrs, caret);
4541 }
4542
4543 bool
4544 InfoManager::remoteinput_commit_string (const WideString &str)
4545 {
4546     return m_impl->remoteinput_commit_string (str);
4547 }
4548
4549 bool
4550 InfoManager::remoteinput_send_key_event (const KeyEvent &key)
4551 {
4552     return m_impl->remoteinput_send_key_event (key);
4553 }
4554
4555 bool
4556 InfoManager::remoteinput_forward_key_event (const KeyEvent &key)
4557 {
4558     return m_impl->remoteinput_forward_key_event (key);
4559 }
4560
4561 bool
4562 InfoManager::remoteinput_delete_surrounding_text (uint32 offset, uint32 len)
4563 {
4564     return m_impl->remoteinput_delete_surrounding_text (offset, len);
4565 }
4566
4567 /////////////////////////////////Message function begin/////////////////////////////////////////
4568
4569 //ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE
4570 bool InfoManager:: reset_keyboard_ise (void)
4571 {
4572     return m_impl->reset_keyboard_ise ();
4573 }
4574
4575 //ISM_TRANS_CMD_SHOW_ISF_CONTROL
4576 void InfoManager::show_isf_panel (int client_id)
4577 {
4578     m_impl->show_isf_panel (client_id);
4579 }
4580
4581 //ISM_TRANS_CMD_HIDE_ISF_CONTROL
4582 void InfoManager::hide_isf_panel (int client_id)
4583 {
4584     m_impl->hide_isf_panel (client_id);
4585 }
4586
4587 //ISM_TRANS_CMD_SHOW_ISE_PANEL
4588 void InfoManager::show_ise_panel (int client_id, uint32 client, uint32 context, char*   data, size_t  len)
4589 {
4590     m_impl->show_ise_panel (client_id, client, context, data, len);
4591 }
4592
4593 //ISM_TRANS_CMD_HIDE_ISE_PANEL
4594 void InfoManager::hide_ise_panel (int client_id, uint32 client, uint32 context)
4595 {
4596     m_impl->hide_ise_panel (client_id, client, context);
4597 }
4598
4599 //ISM_TRANS_CMD_HIDE_ISE_PANEL from ISF control
4600 void InfoManager::hide_helper_ise (void)
4601 {
4602     m_impl->hide_helper_ise ();
4603 }
4604
4605 //ISM_TRANS_CMD_LAUNCH_ISE from ISF control
4606 void InfoManager::launch_helper_ise (void)
4607 {
4608     m_impl->launch_helper_ise ();
4609 }
4610
4611 //SCIM_TRANS_CMD_PROCESS_KEY_EVENT
4612 bool InfoManager::process_key_event (KeyEvent& key, uint32 serial)
4613 {
4614     return m_impl->process_key_event (key, serial);
4615 }
4616
4617 //ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY
4618 void InfoManager::get_input_panel_geometry (int client_id, _OUT_ struct rectinfo& info)
4619 {
4620     m_impl->get_input_panel_geometry (client_id, info);
4621 }
4622
4623 //ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY
4624 void InfoManager::get_candidate_window_geometry (int client_id, _OUT_ struct rectinfo& info)
4625 {
4626     m_impl->get_candidate_window_geometry (client_id, info);
4627 }
4628
4629 //ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE
4630 void InfoManager::get_ise_language_locale (int client_id, _OUT_ char** data, _OUT_ size_t& len)
4631 {
4632     m_impl->get_ise_language_locale (client_id, data, len);
4633 }
4634
4635 //ISM_TRANS_CMD_SET_LAYOUT
4636 void InfoManager::set_ise_layout (int client_id, uint32 layout)
4637 {
4638     m_impl->set_ise_layout (client_id, layout);
4639 }
4640
4641 //ISM_TRANS_CMD_SET_INPUT_MODE
4642 void InfoManager::set_ise_input_mode (int client_id, uint32 input_mode)
4643 {
4644     m_impl->set_ise_input_mode (client_id, input_mode);
4645 }
4646
4647 //ISM_TRANS_CMD_SET_INPUT_HINT
4648 void InfoManager::set_ise_input_hint (int client_id, uint32 input_hint)
4649 {
4650     m_impl->set_ise_input_hint (client_id, input_hint);
4651 }
4652
4653 //ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION
4654 void InfoManager::update_ise_bidi_direction (int client_id, uint32 bidi_direction)
4655 {
4656     m_impl->update_ise_bidi_direction (client_id, bidi_direction);
4657 }
4658
4659
4660 //ISM_TRANS_CMD_SET_ISE_LANGUAGE
4661 void InfoManager::set_ise_language (int client_id, uint32 language)
4662 {
4663     m_impl->set_ise_language (client_id, language);
4664 }
4665
4666 //ISM_TRANS_CMD_SET_ISE_IMDATA
4667 void InfoManager::set_ise_imdata (int client_id, const char*   imdata, size_t  len)
4668 {
4669     m_impl->set_ise_imdata (client_id, imdata, len);
4670 }
4671
4672 //ISM_TRANS_CMD_GET_ISE_IMDATA
4673 bool InfoManager:: get_ise_imdata (int client_id, _OUT_ char** imdata, _OUT_ size_t& len)
4674 {
4675     return m_impl->get_ise_imdata (client_id, imdata, len);
4676 }
4677
4678 //ISM_TRANS_CMD_GET_LAYOUT
4679 bool InfoManager:: get_ise_layout (int client_id, _OUT_ uint32& layout)
4680 {
4681     return m_impl->get_ise_layout (client_id, layout);
4682 }
4683
4684 //ISM_TRANS_CMD_GET_ISE_STATE
4685 void InfoManager::get_ise_state (int client_id, _OUT_ int& state)
4686 {
4687     m_impl->get_ise_state (client_id, state);
4688 }
4689
4690 //ISM_TRANS_CMD_GET_ACTIVE_ISE
4691 void InfoManager::get_active_ise (int client_id, _OUT_ String& default_uuid)
4692 {
4693     m_impl->get_active_ise (client_id, default_uuid);
4694 }
4695
4696 //ISM_TRANS_CMD_GET_ISE_LIST
4697 void InfoManager::get_ise_list (int client_id, _OUT_ std::vector<String>& strlist)
4698 {
4699     m_impl->get_ise_list (client_id, strlist);
4700 }
4701
4702
4703 //ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO
4704 void InfoManager::get_all_helper_ise_info (int client_id, _OUT_ HELPER_ISE_INFO& info)
4705 {
4706     m_impl->get_all_helper_ise_info (client_id, info);
4707 }
4708
4709 //ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO
4710 //reply SCIM_TRANS_CMD_FAIL or SCIM_TRANS_CMD_OK
4711 void InfoManager::set_enable_helper_ise_info (int client_id, String appid, uint32 is_enabled)
4712 {
4713     m_impl->set_enable_helper_ise_info (client_id, appid, is_enabled);
4714 }
4715
4716 //ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST
4717 //reply SCIM_TRANS_CMD_FAIL or SCIM_TRANS_CMD_OK
4718 void InfoManager::show_helper_ise_list (int client_id)
4719 {
4720     m_impl->show_helper_ise_list (client_id);
4721 }
4722
4723
4724 //ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR
4725 //reply SCIM_TRANS_CMD_FAIL or SCIM_TRANS_CMD_OK
4726 void InfoManager::show_helper_ise_selector (int client_id)
4727 {
4728     m_impl->show_helper_ise_selector (client_id);
4729 }
4730
4731 //ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED
4732 //reply
4733 void InfoManager::is_helper_ise_enabled (int client_id, String strAppid, _OUT_ uint32& nEnabled)
4734 {
4735     m_impl->is_helper_ise_enabled (client_id, strAppid, nEnabled);
4736 }
4737
4738 //ISM_TRANS_CMD_GET_ISE_INFORMATION
4739 void InfoManager::get_ise_information (int client_id, String strUuid, _OUT_ String& strName, _OUT_ String& strLanguage,
4740                                        _OUT_ int& nType,   _OUT_ int& nOption, _OUT_ String& strModuleName)
4741 {
4742     m_impl->get_ise_information (client_id, strUuid, strName, strLanguage, nType, nOption, strModuleName);
4743 }
4744
4745 //ISM_TRANS_CMD_RESET_ISE_OPTION
4746 //reply SCIM_TRANS_CMD_OK
4747 bool InfoManager:: reset_ise_option (int client_id)
4748 {
4749     return m_impl->reset_ise_option (client_id);
4750 }
4751
4752 //ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID
4753 //reply
4754 bool InfoManager:: set_active_ise_by_uuid (int client_id, char*  buf, size_t  len)
4755 {
4756     return m_impl->set_active_ise_by_uuid (client_id, buf, len);
4757 }
4758
4759 //ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID
4760 //reply SCIM_TRANS_CMD_FAIL or SCIM_TRANS_CMD_OK
4761 void InfoManager::set_initial_ise_by_uuid (int client_id, char*  buf, size_t  len)
4762 {
4763     m_impl->set_initial_ise_by_uuid (client_id, buf, len);
4764 }
4765
4766 //ISM_TRANS_CMD_SET_RETURN_KEY_TYPE
4767 void InfoManager::set_ise_return_key_type (int client_id, uint32 type)
4768 {
4769     m_impl->set_ise_return_key_type (client_id, type);
4770 }
4771
4772 //ISM_TRANS_CMD_GET_RETURN_KEY_TYPE
4773 //reply
4774 bool InfoManager:: get_ise_return_key_type (int client_id, _OUT_ uint32& type)
4775 {
4776     return m_impl->get_ise_return_key_type (client_id, type);
4777 }
4778
4779
4780 //ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE
4781 void InfoManager::set_ise_return_key_disable (int client_id, uint32 disabled)
4782 {
4783     m_impl->set_ise_return_key_disable (client_id, disabled);
4784 }
4785
4786 //ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE
4787 bool InfoManager::get_ise_return_key_disable (int client_id, _OUT_ uint32& disabled)
4788 {
4789     return m_impl->get_ise_return_key_disable (client_id, disabled);
4790 }
4791
4792 //ISM_TRANS_CMD_SET_CAPS_MODE
4793 void InfoManager::set_ise_caps_mode (int client_id, uint32 mode)
4794 {
4795     m_impl->set_ise_caps_mode (client_id, mode);
4796 }
4797
4798 //SCIM_TRANS_CMD_RELOAD_CONFIG
4799 void InfoManager::reload_config (void)
4800 {
4801     m_impl->reload_config ();
4802 }
4803
4804 //ISM_TRANS_CMD_SEND_WILL_SHOW_ACK
4805 void InfoManager::will_show_ack (int client_id)
4806 {
4807     m_impl->will_show_ack (client_id);
4808 }
4809
4810 //ISM_TRANS_CMD_SEND_WILL_HIDE_ACK
4811 void InfoManager::will_hide_ack (int client_id)
4812 {
4813     m_impl->will_hide_ack (client_id);
4814 }
4815
4816 //ISM_TRANS_CMD_RESET_DEFAULT_ISE
4817 void InfoManager::reset_default_ise (int client_id)
4818 {
4819     m_impl->reset_default_ise (client_id);
4820 }
4821
4822 //ISM_TRANS_CMD_SET_HARDWARE_KEYBOARD_MODE
4823 void InfoManager::set_keyboard_mode (int client_id, uint32 mode)
4824 {
4825     m_impl->set_keyboard_mode (client_id, mode);
4826 }
4827
4828 //ISM_TRANS_CMD_SEND_CANDIDATE_WILL_HIDE_ACK
4829 void InfoManager::candidate_will_hide_ack (int client_id)
4830 {
4831     m_impl->candidate_will_hide_ack (client_id);
4832 }
4833
4834 //ISM_TRANS_CMD_GET_ACTIVE_HELPER_OPTION
4835 void InfoManager::get_active_helper_option (int client_id, _OUT_ uint32& option)
4836 {
4837     m_impl->get_active_helper_option (client_id, option);
4838 }
4839
4840 //ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW
4841 void InfoManager::show_ise_option_window (int client_id)
4842 {
4843     m_impl->show_ise_option_window (client_id);
4844 }
4845
4846 //ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW
4847 void InfoManager::resume_ise_option_window (int client_id)
4848 {
4849     m_impl->resume_ise_option_window (client_id);
4850 }
4851
4852 //ISM_TRANS_CMD_SET_KEYBOARD_MODE
4853 void InfoManager::set_ise_keyboard_mode (int client_id, uint32 mode)
4854 {
4855     m_impl->set_ise_keyboard_mode (client_id, mode);
4856 }
4857
4858 //ISM_TRANS_CMD_SET_PREDICTION_HINT
4859 void InfoManager::set_prediction_hint (int client_id, String prediction_hint)
4860 {
4861     m_impl->set_prediction_hint (client_id, prediction_hint);
4862 }
4863
4864 //ISM_TRANS_CMD_SET_MIME_TYPE
4865 void InfoManager::set_ise_mime_type (int client_id, String mime_type)
4866 {
4867     m_impl->set_ise_mime_type (client_id, mime_type);
4868 }
4869
4870 //ISM_TRANS_CMD_FINALIZE_CONTENT
4871 void InfoManager::finalize_content (int client_id, String text, uint32 cursor_pos)
4872 {
4873     m_impl->finalize_content (client_id, text, cursor_pos);
4874 }
4875
4876 //ISM_TRANS_CMD_SET_PREDICTION_HINT_DATA
4877 void InfoManager::set_prediction_hint_data (int client_id, String key, String value)
4878 {
4879     m_impl->set_prediction_hint_data (client_id, key, value);
4880 }
4881
4882 //ISM_TRANS_CMD_EXPAND_CANDIDATE
4883 void InfoManager::expand_candidate ()
4884 {
4885     m_impl->expand_candidate ();
4886 }
4887
4888 //ISM_TRANS_CMD_CONTRACT_CANDIDATE
4889 void InfoManager::contract_candidate ()
4890 {
4891     m_impl->contract_candidate ();
4892 }
4893
4894 //ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY
4895 void InfoManager::get_recent_ise_geometry (int client_id, uint32 angle, _OUT_ struct rectinfo& info)
4896 {
4897     m_impl->get_recent_ise_geometry (client_id, angle, info);
4898 }
4899
4900 //ISM_TRANS_CMD_SEND_REMOTE_INPUT_MESSAGE
4901 bool InfoManager::remoteinput_send_input_message (int client_id, char* buf, size_t len)
4902 {
4903     return m_impl->send_remote_input_message (client_id, buf, len);
4904 }
4905
4906 void InfoManager::remoteinput_send_surrounding_text (const char* text, uint32 cursor)
4907 {
4908     return m_impl->send_remote_surrounding_text (text, cursor);
4909 }
4910
4911 //ISM_TRANS_CMD_REGISTER_PANEL_CLIENT
4912 void InfoManager::register_panel_client (uint32 client_id, uint32 id)
4913 {
4914     m_impl->register_panel_client (client_id, id);
4915 }
4916
4917 //SCIM_TRANS_CMD_PANEL_REGISTER_INPUT_CONTEXT
4918 void InfoManager::register_input_context (uint32 client_id, uint32 context, String  uuid)
4919 {
4920     m_impl->register_input_context (client_id, context, uuid);
4921 }
4922
4923 //SCIM_TRANS_CMD_PANEL_REMOVE_INPUT_CONTEXT
4924 void InfoManager::remove_input_context (uint32 client_id, uint32 context)
4925 {
4926     m_impl->remove_input_context (client_id, context);
4927 }
4928
4929 //SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT
4930 void InfoManager::socket_reset_input_context (int client_id, uint32 context)
4931 {
4932     m_impl->socket_reset_input_context (client_id, context);
4933 }
4934
4935 //SCIM_TRANS_CMD_FOCUS_IN
4936 void InfoManager::focus_in (int client_id, uint32 context,  String  uuid)
4937 {
4938     m_impl->focus_in (client_id, context, uuid);
4939 }
4940
4941 //SCIM_TRANS_CMD_FOCUS_OUT
4942 void InfoManager::focus_out (int client_id, uint32 context)
4943 {
4944     m_impl->focus_out (client_id, context);
4945 }
4946
4947 //ISM_TRANS_CMD_PROCESS_INPUT_DEVICE_EVENT
4948 bool InfoManager::process_input_device_event(int client, uint32 type, const char *data, size_t len, _OUT_ uint32& result)
4949 {
4950     return m_impl->process_input_device_event(client, type, data, len, result);
4951 }
4952
4953 //ISM_TRANS_CMD_TURN_ON_LOG
4954 void InfoManager::socket_turn_on_log (uint32 isOn)
4955 {
4956     m_impl->socket_turn_on_log (isOn);
4957 }
4958
4959 //SCIM_TRANS_CMD_PANEL_TURN_ON
4960 void InfoManager::socket_turn_on (void)
4961 {
4962     m_impl->socket_turn_on ();
4963 }
4964
4965 //SCIM_TRANS_CMD_PANEL_TURN_OFF
4966 void InfoManager::socket_turn_off (void)
4967 {
4968     m_impl->socket_turn_off ();
4969 }
4970
4971 //SCIM_TRANS_CMD_UPDATE_SCREEN
4972 void InfoManager::socket_update_screen (int client_id, uint32 num)
4973 {
4974     m_impl->socket_update_screen (client_id, num);
4975 }
4976
4977 //SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION
4978 void InfoManager::socket_update_spot_location (uint32 x, uint32 y, uint32 top_y)
4979 {
4980     m_impl->socket_update_spot_location (x, y, top_y);
4981 }
4982
4983 //ISM_TRANS_CMD_UPDATE_CURSOR_POSITION
4984 void InfoManager::socket_update_cursor_position (uint32 cursor_pos)
4985 {
4986     m_impl->socket_update_cursor_position (cursor_pos);
4987 }
4988
4989 //ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT
4990 void InfoManager::socket_update_surrounding_text (String text, uint32 cursor)
4991 {
4992     m_impl->socket_update_surrounding_text (text, cursor);
4993 }
4994
4995 void InfoManager::remoteinput_callback_focus_in (void)
4996 {
4997     m_impl->remoteinput_callback_focus_in ();
4998 }
4999
5000 void InfoManager::remoteinput_callback_focus_out (void)
5001 {
5002     m_impl->remoteinput_callback_focus_out ();
5003 }
5004
5005 void InfoManager::remoteinput_callback_entry_metadata (uint32 hint, uint32 layout, int variation, uint32 autocapital_type, int return_key_disabled)
5006 {
5007     m_impl->remoteinput_callback_entry_metadata (hint, layout, variation, autocapital_type, return_key_disabled);
5008 }
5009
5010 void InfoManager::remoteinput_callback_surrounding_text (String text, uint32 cursor)
5011 {
5012     m_impl->remoteinput_callback_surrounding_text (text, cursor);
5013 }
5014
5015 void InfoManager::remoteinput_callback_input_resource (uint32 input_resource)
5016 {
5017     m_impl->remoteinput_callback_input_resource (input_resource);
5018 }
5019
5020 //ISM_TRANS_CMD_UPDATE_SELECTION
5021 void InfoManager::socket_update_selection (String text)
5022 {
5023     m_impl->socket_update_selection (text);
5024 }
5025
5026 //FIXME: useless anymore
5027 //SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO
5028 void InfoManager::socket_update_factory_info (PanelFactoryInfo& info)
5029 {
5030     m_impl->socket_update_factory_info (info);
5031 }
5032
5033 //SCIM_TRANS_CMD_PANEL_SHOW_HELP
5034 void InfoManager::socket_show_help (String help)
5035 {
5036     m_impl->socket_show_help (help);
5037 }
5038
5039 //SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU
5040 void InfoManager::socket_show_factory_menu (std::vector <PanelFactoryInfo>& vec)
5041 {
5042     m_impl->socket_show_factory_menu (vec);
5043 }
5044
5045 //SCIM_TRANS_CMD_SHOW_PREEDIT_STRING
5046 void InfoManager::socket_show_preedit_string (void)
5047 {
5048     m_impl->socket_show_preedit_string ();
5049 }
5050
5051 //SCIM_TRANS_CMD_SHOW_AUX_STRING
5052 void InfoManager::socket_show_aux_string (void)
5053 {
5054     m_impl->socket_show_aux_string ();
5055 }
5056
5057 //SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE
5058 void InfoManager::socket_show_lookup_table (void)
5059 {
5060     m_impl->socket_show_lookup_table ();
5061 }
5062
5063 //ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE
5064 void InfoManager::socket_show_associate_table (void)
5065 {
5066     m_impl->socket_show_associate_table ();
5067 }
5068
5069 //SCIM_TRANS_CMD_HIDE_PREEDIT_STRING
5070 void InfoManager::socket_hide_preedit_string (void)
5071 {
5072     m_impl->socket_hide_preedit_string ();
5073 }
5074
5075 //SCIM_TRANS_CMD_HIDE_AUX_STRING
5076 void InfoManager::socket_hide_aux_string (void)
5077 {
5078     m_impl->socket_hide_aux_string ();
5079 }
5080
5081 //SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE
5082 void InfoManager::socket_hide_lookup_table (void)
5083 {
5084     m_impl->socket_hide_lookup_table ();
5085 }
5086
5087 //ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE
5088 void InfoManager::socket_hide_associate_table (void)
5089 {
5090     m_impl->socket_hide_associate_table ();
5091 }
5092
5093 //SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING
5094 void InfoManager::socket_update_preedit_string (String& str, const AttributeList& attrs, uint32 caret)
5095 {
5096     m_impl->socket_update_preedit_string (str, attrs, caret);
5097 }
5098
5099 //SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET
5100 void InfoManager::socket_update_preedit_caret (uint32 caret)
5101 {
5102     m_impl->socket_update_preedit_caret (caret);
5103 }
5104
5105 //ISM_TRANS_CMD_RECAPTURE_STRING
5106 void InfoManager::socket_recapture_string (int offset, int len, String& preedit, String& commit, const AttributeList& attrs)
5107 {
5108     m_impl->socket_recapture_string (offset, len, preedit, commit, attrs);
5109 }
5110
5111 //SCIM_TRANS_CMD_UPDATE_AUX_STRING
5112 void InfoManager::socket_update_aux_string (String& str, const AttributeList& attrs)
5113 {
5114     m_impl->socket_update_aux_string (str, attrs);
5115 }
5116
5117 //SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE
5118 void InfoManager::socket_update_lookup_table (const LookupTable& table)
5119 {
5120     m_impl->socket_update_lookup_table (table);
5121 }
5122
5123 //ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE
5124 void InfoManager::socket_update_associate_table (const LookupTable& table)
5125 {
5126     m_impl->socket_update_associate_table (table);
5127 }
5128
5129 //SCIM_TRANS_CMD_REGISTER_PROPERTIES
5130 void InfoManager::socket_register_properties (const PropertyList& properties)
5131 {
5132     m_impl->socket_register_properties (properties);
5133 }
5134
5135 //SCIM_TRANS_CMD_UPDATE_PROPERTY
5136 void InfoManager::socket_update_property (const Property& property)
5137 {
5138     m_impl->socket_update_property (property);
5139 }
5140
5141 //ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST
5142 void InfoManager::socket_get_keyboard_ise_list (String& uuid)
5143 {
5144     m_impl->socket_get_keyboard_ise_list (uuid);
5145 }
5146
5147 //ISM_TRANS_CMD_SET_CANDIDATE_UI
5148 void InfoManager::socket_set_candidate_ui (uint32 portrait_line, uint32 mode)
5149 {
5150     m_impl->socket_set_candidate_ui (portrait_line, mode);
5151 }
5152
5153 //ISM_TRANS_CMD_GET_CANDIDATE_UI
5154 void InfoManager::socket_get_candidate_ui (String uuid)
5155 {
5156     m_impl->socket_get_candidate_ui (uuid);
5157 }
5158
5159 //ISM_TRANS_CMD_SET_CANDIDATE_POSITION
5160 void InfoManager::socket_set_candidate_position (uint32 left, uint32 top)
5161 {
5162     m_impl->socket_set_candidate_position (left, top);
5163 }
5164
5165 //ISM_TRANS_CMD_HIDE_CANDIDATE
5166 void InfoManager::socket_hide_candidate (void)
5167 {
5168     m_impl->socket_hide_candidate ();
5169 }
5170
5171 //ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY
5172 void InfoManager::socket_get_candidate_geometry (String& uuid)
5173 {
5174     m_impl->socket_get_candidate_geometry (uuid);
5175 }
5176
5177 //ISM_TRANS_CMD_SET_KEYBOARD_ISE_BY_UUID
5178 void InfoManager::socket_set_keyboard_ise (String uuid)
5179 {
5180     m_impl->socket_set_keyboard_ise (uuid);
5181 }
5182
5183 //ISM_TRANS_CMD_SELECT_CANDIDATE
5184 void InfoManager::socket_helper_select_candidate (uint32 index)
5185 {
5186     m_impl->socket_helper_select_candidate (index);
5187 }
5188
5189 //ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY
5190 void InfoManager::socket_helper_update_ise_geometry (int client, uint32 x, uint32 y, uint32 width, uint32 height)
5191 {
5192     m_impl->socket_helper_update_ise_geometry (client, x, y, width, height);
5193 }
5194
5195 //ISM_TRANS_CMD_GET_KEYBOARD_ISE
5196 void InfoManager::socket_get_keyboard_ise (String uuid)
5197 {
5198     m_impl->socket_get_keyboard_ise (uuid);
5199 }
5200
5201 //SCIM_TRANS_CMD_START_HELPER
5202 void InfoManager::socket_start_helper (int client_id, uint32 context, String uuid)
5203 {
5204     m_impl->socket_start_helper (client_id, context, uuid);
5205 }
5206
5207 //SCIM_TRANS_CMD_STOP_HELPER
5208 void InfoManager::socket_stop_helper (int client_id, uint32 context, String uuid)
5209 {
5210     m_impl->socket_stop_helper (client_id, context, uuid);
5211 }
5212
5213 //SCIM_TRANS_CMD_SEND_HELPER_EVENT
5214 void InfoManager::socket_send_helper_event (int client_id, uint32 context, String uuid, const Transaction& _nest_trans)
5215 {
5216     m_impl->socket_send_helper_event (client_id, context, uuid, _nest_trans);
5217 }
5218
5219 //SCIM_TRANS_CMD_REGISTER_PROPERTIES
5220 void InfoManager::socket_helper_register_properties (int client, PropertyList& properties)
5221 {
5222     m_impl->socket_helper_register_properties (client, properties);
5223 }
5224
5225 //SCIM_TRANS_CMD_UPDATE_PROPERTY
5226 void InfoManager::socket_helper_update_property (int client, Property& property)
5227 {
5228     m_impl->socket_helper_update_property (client, property);
5229 }
5230
5231 //SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT
5232 void InfoManager::socket_helper_send_imengine_event (int client, uint32 target_ic, String target_uuid , Transaction& nest_trans)
5233 {
5234     m_impl->socket_helper_send_imengine_event (client, target_ic, target_uuid, nest_trans);
5235 }
5236
5237 //SCIM_TRANS_CMD_PROCESS_KEY_EVENT
5238 //SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT
5239 void InfoManager::socket_helper_send_key_event (int client, uint32 target_ic, String target_uuid, KeyEvent key)
5240 {
5241     m_impl->socket_helper_send_key_event (client, target_ic, target_uuid, key);
5242 }
5243
5244 //SCIM_TRANS_CMD_FORWARD_KEY_EVENT
5245 void InfoManager::socket_helper_forward_key_event (int client, uint32 target_ic, String target_uuid, KeyEvent key)
5246 {
5247     m_impl->socket_helper_forward_key_event (client, target_ic, target_uuid, key);
5248 }
5249
5250 //SCIM_TRANS_CMD_COMMIT_STRING
5251 void InfoManager::socket_helper_commit_string (int client, uint32 target_ic, String target_uuid, WideString wstr)
5252 {
5253     m_impl->socket_helper_commit_string (client, target_ic, target_uuid, wstr);
5254 }
5255
5256 //SCIM_TRANS_CMD_GET_SURROUNDING_TEXT
5257 void InfoManager::socket_helper_get_surrounding_text (int client, String uuid, uint32 maxlen_before, uint32 maxlen_after)
5258 {
5259     m_impl->socket_helper_get_surrounding_text (client, uuid, maxlen_before, maxlen_after);
5260 }
5261
5262 //SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT
5263 void InfoManager::socket_helper_delete_surrounding_text (int client, uint32 offset, uint32 len)
5264 {
5265     m_impl->socket_helper_delete_surrounding_text (client, offset, len);
5266 }
5267
5268 //SCIM_TRANS_CMD_GET_SELECTION
5269 void InfoManager::socket_helper_get_selection (int client, String uuid)
5270 {
5271     m_impl->socket_helper_get_selection (client, uuid);
5272 }
5273
5274 //SCIM_TRANS_CMD_SET_SELECTION
5275 void InfoManager::socket_helper_set_selection (int client, uint32 start, uint32 end)
5276 {
5277     m_impl->socket_helper_set_selection (client, start, end);
5278 }
5279
5280 //SCIM_TRANS_CMD_SHOW_PREEDIT_STRING
5281 void InfoManager::socket_helper_show_preedit_string (int client, uint32 target_ic, String target_uuid)
5282 {
5283     m_impl->socket_helper_show_preedit_string (client, target_ic, target_uuid);
5284 }
5285
5286 //SCIM_TRANS_CMD_HIDE_PREEDIT_STRING
5287 void InfoManager::socket_helper_hide_preedit_string (int client, uint32 target_ic, String target_uuid)
5288 {
5289     m_impl->socket_helper_hide_preedit_string (client, target_ic, target_uuid);
5290 }
5291
5292 //SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING
5293 void InfoManager::socket_helper_update_preedit_string (int client, uint32 target_ic, String target_uuid, WideString preedit,
5294         WideString commit, AttributeList& attrs, uint32 caret)
5295 {
5296     m_impl->socket_helper_update_preedit_string (client, target_ic, target_uuid, preedit, commit, attrs, caret);
5297 }
5298
5299 //SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET
5300 void InfoManager::socket_helper_update_preedit_caret (int client, uint32 caret)
5301 {
5302     m_impl->socket_helper_update_preedit_caret (client, caret);
5303 }
5304
5305 //ISM_TRANS_CMD_RECAPTURE_STRING
5306 void InfoManager::socket_helper_recapture_string (int client, uint32 target_ic, String target_uuid, int offset, int len, WideString preedit,
5307         WideString commit, AttributeList& attrs)
5308 {
5309     m_impl->socket_helper_recapture_string (client, target_ic, target_uuid, offset, len, preedit, commit, attrs);
5310 }
5311
5312 //SCIM_TRANS_CMD_PANEL_REGISTER_HELPER
5313 void InfoManager::socket_helper_register_helper (int client, HelperInfo& info)
5314 {
5315     m_impl->socket_helper_register_helper (client, info);
5316 }
5317
5318 //SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER
5319 void InfoManager::socket_helper_register_helper_passive (int client, HelperInfo& info)
5320 {
5321     m_impl->socket_helper_register_helper_passive (client, info);
5322 }
5323
5324 //ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT
5325 void InfoManager::socket_helper_update_input_context (int client, uint32 type, uint32 value)
5326 {
5327     m_impl->socket_helper_update_input_context (client, type, value);
5328 }
5329
5330 //ISM_TRANS_CMD_UPDATE_ISE_LANGUAGE_LOCALE
5331 void InfoManager::socket_helper_update_language_locale(int client, String locale)
5332 {
5333     m_impl->socket_helper_update_language_locale(client, locale);
5334 }
5335
5336 //SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND
5337 void InfoManager::socket_helper_send_private_command (int client, String command)
5338 {
5339     m_impl->socket_helper_send_private_command (client, command);
5340 }
5341
5342 //SCIM_TRANS_CMD_COMMIT_CONTENT
5343 void InfoManager::socket_helper_commit_content (int client, String content, String description, String mime_types)
5344 {
5345     m_impl->socket_helper_commit_content (client, content, description, mime_types);
5346 }
5347
5348 //ISM_TRANS_CMD_UPDATE_ISE_EXIT
5349 //void InfoManager::UPDATE_ISE_EXIT (int client)
5350 //{
5351 //    m_impl->UPDATE_ISE_EXIT (client);
5352 //}
5353
5354 //ISM_TRANS_CMD_PROCESS_KEY_EVENT_DONE
5355 void InfoManager::process_key_event_done (KeyEvent &key, uint32 ret, uint32 serial)
5356 {
5357     m_impl->process_key_event_done (key, ret, serial);
5358 }
5359
5360 //ISM_TRANS_CMD_REQUEST_ISE_HIDE
5361 void InfoManager::request_ise_hide ()
5362 {
5363     m_impl->request_ise_hide ();
5364 }
5365
5366 bool InfoManager::check_privilege_by_sockfd (int client_id, const String& privilege) {
5367     return m_impl->check_privilege_by_sockfd (client_id, privilege);
5368 }
5369
5370 void InfoManager::add_client (int client_id, uint32 key, ClientType type)
5371 {
5372     m_impl->add_client (client_id, key, type);
5373 }
5374
5375 void InfoManager::del_client (int client_id)
5376 {
5377     m_impl->del_client (client_id);
5378 }
5379
5380 bool InfoManager::set_autocapital_type (int mode)
5381 {
5382     return m_impl->set_autocapital_type (mode);
5383 }
5384
5385 void InfoManager::set_prediction_allow (int client, bool mode)
5386 {
5387     m_impl->set_prediction_allow (client, mode);
5388 }
5389
5390 void InfoManager::reshow_input_panel ()
5391 {
5392     m_impl->reshow_input_panel ();
5393 }
5394
5395 //////////////////////////////////Message function end/////////////////////////////////////////
5396
5397 Connection
5398 InfoManager::signal_connect_turn_on (InfoManagerSlotVoid*                slot)
5399 {
5400     return m_impl->signal_connect_turn_on (slot);
5401 }
5402
5403 Connection
5404 InfoManager::signal_connect_turn_off (InfoManagerSlotVoid*                slot)
5405 {
5406     return m_impl->signal_connect_turn_off (slot);
5407 }
5408
5409 Connection
5410 InfoManager::signal_connect_show_panel (InfoManagerSlotVoid*                slot)
5411 {
5412     return m_impl->signal_connect_show_panel (slot);
5413 }
5414
5415 Connection
5416 InfoManager::signal_connect_hide_panel (InfoManagerSlotVoid*                slot)
5417 {
5418     return m_impl->signal_connect_hide_panel (slot);
5419 }
5420
5421 Connection
5422 InfoManager::signal_connect_update_screen (InfoManagerSlotInt*                 slot)
5423 {
5424     return m_impl->signal_connect_update_screen (slot);
5425 }
5426
5427 Connection
5428 InfoManager::signal_connect_update_spot_location (InfoManagerSlotIntIntInt*           slot)
5429 {
5430     return m_impl->signal_connect_update_spot_location (slot);
5431 }
5432
5433 Connection
5434 InfoManager::signal_connect_update_factory_info (InfoManagerSlotFactoryInfo*         slot)
5435 {
5436     return m_impl->signal_connect_update_factory_info (slot);
5437 }
5438
5439 Connection
5440 InfoManager::signal_connect_start_default_ise (InfoManagerSlotVoid*                slot)
5441 {
5442     return m_impl->signal_connect_start_default_ise (slot);
5443 }
5444
5445 Connection
5446 InfoManager::signal_connect_stop_default_ise (InfoManagerSlotVoid*                slot)
5447 {
5448     return m_impl->signal_connect_stop_default_ise (slot);
5449 }
5450
5451 Connection
5452 InfoManager::signal_connect_set_candidate_ui (InfoManagerSlotIntInt*              slot)
5453 {
5454     return m_impl->signal_connect_set_candidate_ui (slot);
5455 }
5456
5457 Connection
5458 InfoManager::signal_connect_get_candidate_ui (InfoManagerSlotIntInt2*             slot)
5459 {
5460     return m_impl->signal_connect_get_candidate_ui (slot);
5461 }
5462
5463 Connection
5464 InfoManager::signal_connect_set_candidate_position (InfoManagerSlotIntInt*              slot)
5465 {
5466     return m_impl->signal_connect_set_candidate_position (slot);
5467 }
5468
5469 Connection
5470 InfoManager::signal_connect_get_candidate_geometry (InfoManagerSlotRect*                slot)
5471 {
5472     return m_impl->signal_connect_get_candidate_geometry (slot);
5473 }
5474
5475 Connection
5476 InfoManager::signal_connect_get_input_panel_geometry (InfoManagerSlotRect*                slot)
5477 {
5478     return m_impl->signal_connect_get_input_panel_geometry (slot);
5479 }
5480
5481 Connection
5482 InfoManager::signal_connect_set_keyboard_ise (InfoManagerSlotString*              slot)
5483 {
5484     return m_impl->signal_connect_set_keyboard_ise (slot);
5485 }
5486
5487 Connection
5488 InfoManager::signal_connect_get_keyboard_ise (InfoManagerSlotString2*             slot)
5489 {
5490     return m_impl->signal_connect_get_keyboard_ise (slot);
5491 }
5492
5493 Connection
5494 InfoManager::signal_connect_show_help (InfoManagerSlotString*              slot)
5495 {
5496     return m_impl->signal_connect_show_help (slot);
5497 }
5498
5499 Connection
5500 InfoManager::signal_connect_show_factory_menu (InfoManagerSlotFactoryInfoVector*   slot)
5501 {
5502     return m_impl->signal_connect_show_factory_menu (slot);
5503 }
5504
5505 Connection
5506 InfoManager::signal_connect_show_preedit_string (InfoManagerSlotVoid*                slot)
5507 {
5508     return m_impl->signal_connect_show_preedit_string (slot);
5509 }
5510
5511 Connection
5512 InfoManager::signal_connect_show_aux_string (InfoManagerSlotVoid*                slot)
5513 {
5514     return m_impl->signal_connect_show_aux_string (slot);
5515 }
5516
5517 Connection
5518 InfoManager::signal_connect_show_lookup_table (InfoManagerSlotVoid*                slot)
5519 {
5520     return m_impl->signal_connect_show_lookup_table (slot);
5521 }
5522
5523 Connection
5524 InfoManager::signal_connect_show_associate_table (InfoManagerSlotVoid*                slot)
5525 {
5526     return m_impl->signal_connect_show_associate_table (slot);
5527 }
5528
5529 Connection
5530 InfoManager::signal_connect_hide_preedit_string (InfoManagerSlotVoid*                slot)
5531 {
5532     return m_impl->signal_connect_hide_preedit_string (slot);
5533 }
5534
5535 Connection
5536 InfoManager::signal_connect_hide_aux_string (InfoManagerSlotVoid*                slot)
5537 {
5538     return m_impl->signal_connect_hide_aux_string (slot);
5539 }
5540
5541 Connection
5542 InfoManager::signal_connect_hide_lookup_table (InfoManagerSlotVoid*                slot)
5543 {
5544     return m_impl->signal_connect_hide_lookup_table (slot);
5545 }
5546
5547 Connection
5548 InfoManager::signal_connect_hide_associate_table (InfoManagerSlotVoid*                slot)
5549 {
5550     return m_impl->signal_connect_hide_associate_table (slot);
5551 }
5552
5553 Connection
5554 InfoManager::signal_connect_update_preedit_string (InfoManagerSlotAttributeStringInt*  slot)
5555 {
5556     return m_impl->signal_connect_update_preedit_string (slot);
5557 }
5558
5559 Connection
5560 InfoManager::signal_connect_update_preedit_caret (InfoManagerSlotInt*                 slot)
5561 {
5562     return m_impl->signal_connect_update_preedit_caret (slot);
5563 }
5564
5565 Connection
5566 InfoManager::signal_connect_update_aux_string (InfoManagerSlotAttributeString*     slot)
5567 {
5568     return m_impl->signal_connect_update_aux_string (slot);
5569 }
5570
5571 Connection
5572 InfoManager::signal_connect_update_lookup_table (InfoManagerSlotLookupTable*         slot)
5573 {
5574     return m_impl->signal_connect_update_lookup_table (slot);
5575 }
5576
5577 Connection
5578 InfoManager::signal_connect_update_associate_table (InfoManagerSlotLookupTable*         slot)
5579 {
5580     return m_impl->signal_connect_update_associate_table (slot);
5581 }
5582
5583 Connection
5584 InfoManager::signal_connect_register_properties (InfoManagerSlotPropertyList*        slot)
5585 {
5586     return m_impl->signal_connect_register_properties (slot);
5587 }
5588
5589 Connection
5590 InfoManager::signal_connect_update_property (InfoManagerSlotProperty*            slot)
5591 {
5592     return m_impl->signal_connect_update_property (slot);
5593 }
5594
5595 Connection
5596 InfoManager::signal_connect_register_helper_properties (InfoManagerSlotIntPropertyList*     slot)
5597 {
5598     return m_impl->signal_connect_register_helper_properties (slot);
5599 }
5600
5601 Connection
5602 InfoManager::signal_connect_update_helper_property (InfoManagerSlotIntProperty*         slot)
5603 {
5604     return m_impl->signal_connect_update_helper_property (slot);
5605 }
5606
5607 Connection
5608 InfoManager::signal_connect_register_helper (InfoManagerSlotIntHelperInfo*       slot)
5609 {
5610     return m_impl->signal_connect_register_helper (slot);
5611 }
5612
5613 Connection
5614 InfoManager::signal_connect_remove_helper (InfoManagerSlotInt*                 slot)
5615 {
5616     return m_impl->signal_connect_remove_helper (slot);
5617 }
5618
5619 Connection
5620 InfoManager::signal_connect_set_active_ise_by_uuid (InfoManagerSlotStringBool*          slot)
5621 {
5622     return m_impl->signal_connect_set_active_ise_by_uuid (slot);
5623 }
5624
5625 Connection
5626 InfoManager::signal_connect_focus_in (InfoManagerSlotVoid*                slot)
5627 {
5628     return m_impl->signal_connect_focus_in (slot);
5629 }
5630
5631 Connection
5632 InfoManager::signal_connect_focus_out (InfoManagerSlotVoid*                slot)
5633 {
5634     return m_impl->signal_connect_focus_out (slot);
5635 }
5636
5637 Connection
5638 InfoManager::signal_connect_expand_candidate (InfoManagerSlotVoid*                slot)
5639 {
5640     return m_impl->signal_connect_expand_candidate (slot);
5641 }
5642
5643 Connection
5644 InfoManager::signal_connect_contract_candidate (InfoManagerSlotVoid*                slot)
5645 {
5646     return m_impl->signal_connect_contract_candidate (slot);
5647 }
5648
5649 Connection
5650 InfoManager::signal_connect_select_candidate (InfoManagerSlotInt*                 slot)
5651 {
5652     return m_impl->signal_connect_select_candidate (slot);
5653 }
5654
5655 Connection
5656 InfoManager::signal_connect_get_ise_list (InfoManagerSlotBoolStringVector*    slot)
5657 {
5658     return m_impl->signal_connect_get_ise_list (slot);
5659 }
5660
5661 Connection
5662 InfoManager::signal_connect_get_all_helper_ise_info (InfoManagerSlotBoolHelperInfo*      slot)
5663 {
5664     return m_impl->signal_connect_get_all_helper_ise_info (slot);
5665 }
5666
5667 Connection
5668 InfoManager::signal_connect_set_has_option_helper_ise_info (InfoManagerSlotStringBool*      slot)
5669 {
5670     return m_impl->signal_connect_set_has_option_helper_ise_info (slot);
5671 }
5672
5673 Connection
5674 InfoManager::signal_connect_set_enable_helper_ise_info (InfoManagerSlotStringBool*     slot)
5675 {
5676     return m_impl->signal_connect_set_enable_helper_ise_info (slot);
5677 }
5678
5679 Connection
5680 InfoManager::signal_connect_show_helper_ise_list (InfoManagerSlotVoid*                slot)
5681 {
5682     return m_impl->signal_connect_show_helper_ise_list (slot);
5683 }
5684
5685 Connection
5686 InfoManager::signal_connect_show_helper_ise_selector (InfoManagerSlotVoid*                slot)
5687 {
5688     return m_impl->signal_connect_show_helper_ise_selector (slot);
5689 }
5690
5691 Connection
5692 InfoManager::signal_connect_is_helper_ise_enabled (InfoManagerSlotStringInt*           slot)
5693 {
5694     return m_impl->signal_connect_is_helper_ise_enabled (slot);
5695 }
5696
5697 Connection
5698 InfoManager::signal_connect_get_ise_information (InfoManagerSlotBoolString4int2*     slot)
5699 {
5700     return m_impl->signal_connect_get_ise_information (slot);
5701 }
5702
5703 Connection
5704 InfoManager::signal_connect_get_keyboard_ise_list (InfoManagerSlotBoolStringVector*    slot)
5705 {
5706     return m_impl->signal_connect_get_keyboard_ise_list (slot);
5707 }
5708
5709 Connection
5710 InfoManager::signal_connect_update_ise_geometry (InfoManagerSlotIntIntIntInt*        slot)
5711 {
5712     return m_impl->signal_connect_update_ise_geometry (slot);
5713 }
5714
5715 Connection
5716 InfoManager::signal_connect_get_language_list (InfoManagerSlotStringVector*        slot)
5717 {
5718     return m_impl->signal_connect_get_language_list (slot);
5719 }
5720
5721 Connection
5722 InfoManager::signal_connect_get_all_language (InfoManagerSlotStringVector*        slot)
5723 {
5724     return m_impl->signal_connect_get_all_language (slot);
5725 }
5726
5727 Connection
5728 InfoManager::signal_connect_get_ise_language (InfoManagerSlotStrStringVector*     slot)
5729 {
5730     return m_impl->signal_connect_get_ise_language (slot);
5731 }
5732
5733 Connection
5734 InfoManager::signal_connect_get_ise_info_by_uuid (InfoManagerSlotStringISEINFO*       slot)
5735 {
5736     return m_impl->signal_connect_get_ise_info_by_uuid (slot);
5737 }
5738
5739 Connection
5740 InfoManager::signal_connect_send_key_event (InfoManagerSlotKeyEvent*            slot)
5741 {
5742     return m_impl->signal_connect_send_key_event (slot);
5743 }
5744
5745 Connection
5746 InfoManager::signal_connect_accept_connection (InfoManagerSlotInt*                 slot)
5747 {
5748     return m_impl->signal_connect_accept_connection (slot);
5749 }
5750
5751 Connection
5752 InfoManager::signal_connect_close_connection (InfoManagerSlotInt*                 slot)
5753 {
5754     return m_impl->signal_connect_close_connection (slot);
5755 }
5756
5757 Connection
5758 InfoManager::signal_connect_exit (InfoManagerSlotVoid*                slot)
5759 {
5760     return m_impl->signal_connect_exit (slot);
5761 }
5762
5763 Connection
5764 InfoManager::signal_connect_transaction_start (InfoManagerSlotVoid*                slot)
5765 {
5766     return m_impl->signal_connect_transaction_start (slot);
5767 }
5768
5769 Connection
5770 InfoManager::signal_connect_transaction_end (InfoManagerSlotVoid*                slot)
5771 {
5772     return m_impl->signal_connect_transaction_end (slot);
5773 }
5774
5775 Connection
5776 InfoManager::signal_connect_lock (InfoManagerSlotVoid*                slot)
5777 {
5778     return m_impl->signal_connect_lock (slot);
5779 }
5780
5781 Connection
5782 InfoManager::signal_connect_unlock (InfoManagerSlotVoid*                slot)
5783 {
5784     return m_impl->signal_connect_unlock (slot);
5785 }
5786
5787 Connection
5788 InfoManager::signal_connect_update_input_context (InfoManagerSlotIntInt*              slot)
5789 {
5790     return m_impl->signal_connect_update_input_context (slot);
5791 }
5792
5793 Connection
5794 InfoManager::signal_connect_show_ise (InfoManagerSlotVoid*                slot)
5795 {
5796     return m_impl->signal_connect_show_ise (slot);
5797 }
5798
5799 Connection
5800 InfoManager::signal_connect_hide_ise (InfoManagerSlotVoid*                slot)
5801 {
5802     return m_impl->signal_connect_hide_ise (slot);
5803 }
5804
5805 Connection
5806 InfoManager::signal_connect_will_show_ack (InfoManagerSlotVoid*                slot)
5807 {
5808     return m_impl->signal_connect_will_show_ack (slot);
5809 }
5810
5811 Connection
5812 InfoManager::signal_connect_will_hide_ack (InfoManagerSlotVoid*                slot)
5813 {
5814     return m_impl->signal_connect_will_hide_ack (slot);
5815 }
5816
5817 Connection
5818 InfoManager::signal_connect_set_keyboard_mode (InfoManagerSlotInt*                 slot)
5819 {
5820     return m_impl->signal_connect_set_keyboard_mode (slot);
5821 }
5822
5823 Connection
5824 InfoManager::signal_connect_candidate_will_hide_ack (InfoManagerSlotVoid*                slot)
5825 {
5826     return m_impl->signal_connect_candidate_will_hide_ack (slot);
5827 }
5828
5829 Connection
5830 InfoManager::signal_connect_get_ise_state (InfoManagerSlotInt2*                slot)
5831 {
5832     return m_impl->signal_connect_get_ise_state (slot);
5833 }
5834
5835 Connection
5836 InfoManager::signal_connect_run_helper (InfoManagerSlotString3*                slot)
5837 {
5838     return m_impl->signal_connect_run_helper (slot);
5839 }
5840
5841 Connection
5842 InfoManager::signal_connect_launch_option_application (InfoManagerSlotBoolString*                slot)
5843 {
5844     return m_impl->signal_connect_launch_option_application (slot);
5845 }
5846
5847 Connection
5848 InfoManager::signal_connect_get_recent_ise_geometry (InfoManagerSlotIntRect*             slot)
5849 {
5850     return m_impl->signal_connect_get_recent_ise_geometry (slot);
5851 }
5852
5853 Connection
5854 InfoManager::signal_connect_check_privilege_by_sockfd  (InfoManagerSlotIntString2* slot)
5855 {
5856     return m_impl->signal_connect_check_privilege_by_sockfd (slot);
5857 }
5858
5859 Connection
5860 InfoManager::signal_connect_remoteinput_send_input_message  (InfoManagerSlotStringBool*          slot)
5861 {
5862     return m_impl->signal_connect_remoteinput_send_input_message (slot);
5863 }
5864
5865 Connection
5866 InfoManager::signal_connect_remoteinput_send_surrounding_text  (InfoManagerSlotIntString*                slot)
5867 {
5868     return m_impl->signal_connect_remoteinput_send_surrounding_text (slot);
5869 }
5870
5871 } /* namespace scim */
5872
5873 /*
5874 vi:ts=4:nowrap:ai:expandtab
5875 */