ism/modules/panelagent/ecoresocket/ecore_socket_panel_agent_module.cpp

   1 /*
   2  * ISF(Input Service Framework)
   3  *
   4  * ISF is based on SCIM 1.4.7 and extended for supporting more mobile fitable.
   5  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   6  *
   7  * Contact: Li Zhang <li2012.zhang@samsung.com>
   8  *
   9  * This library is free software; you can redistribute it and/or modify it under
  10  * the terms of the GNU Lesser General Public License as published by the
  11  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  12  * any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  15  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  17  * License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  21  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  *
  23  */
  24
  25 #define Uses_SCIM_TRANSACTION
  26 #define Uses_SCIM_TRANS_COMMANDS
  27 #define Uses_SCIM_PANEL_AGENT
  28 #define Uses_SCIM_HELPER
  29 #define Uses_SCIM_SOCKET
  30 #define Uses_SCIM_EVENT
  31 #define Uses_SCIM_CONFIG
  32 #define Uses_SCIM_CONFIG_MODULE
  33 #define Uses_SCIM_CONFIG_PATH
  34 #define Uses_SCIM_UTILITY
  35
  36 #include <string.h>
  37 #include <sys/types.h>
  38 #include <sys/times.h>
  39 #include <dlog.h>
  40 #include <unistd.h>
  41 #include <Ecore.h>
  42 #include "scim_private.h"
  43 #include "scim.h"
  44 #include "scim_stl_map.h"
  45
  46 #ifdef LOG_TAG
  47 # undef LOG_TAG
  48 #endif
  49 #define LOG_TAG             "ISF_ECORE_SOCKET_MODULE"
  50
  51 #define MIN_REPEAT_TIME     2.0
  52
  53 #define IMEMANAGER_PRIVILEGE "http://tizen.org/privilege/imemanager"
  54
  55 namespace scim
  56 {
  57
  58 struct HelperClientStub {
  59     int id;
  60     int ref;
  61
  62     HelperClientStub(int i = 0, int r = 0) : id(i), ref(r) { }
  63 };
  64
  65 struct IMControlStub {
  66     std::vector<ISE_INFO> info;
  67     std::vector<int> count;
  68 };
  69
  70 #define DEFAULT_CONTEXT_VALUE 0xfff
  71
  72 #define scim_module_init ecoresocket_LTX_scim_module_init
  73 #define scim_module_exit ecoresocket_LTX_scim_module_exit
  74 #define scim_panel_agent_module_init ecoresocket_LTX_scim_panel_agent_module_init
  75 #define scim_panel_agent_module_get_instance ecoresocket_LTX_scim_panel_agent_module_get_instance
  76
  77
  78 //==================================== PanelAgent ===========================
  79 class EcoreSocketPanelAgent: public PanelAgentBase
  80 {
  81     bool                                m_should_exit;
  82
  83     int                                 m_socket_timeout;
  84     String                              m_socket_address;
  85     SocketServer                        m_socket_server;
  86
  87     Transaction                         m_send_trans;
  88     Transaction                         m_recv_trans;
  89     Transaction                         m_nest_trans;
  90
  91     bool                                m_should_shared_ise;
  92     bool                                m_ise_exiting;
  93
  94     std::vector<Ecore_Fd_Handler*>     _read_handler_list;
  95
  96     InfoManager* m_info_manager;
  97
  98 public:
  99     EcoreSocketPanelAgent()
 100         : PanelAgentBase ("ecore_socket"),
 101           m_should_exit(false),
 102           m_socket_timeout(scim_get_default_socket_timeout()),
 103           m_should_shared_ise(false),
 104           m_ise_exiting(false) {
 105         m_socket_server.signal_connect_accept(slot(this, &EcoreSocketPanelAgent::socket_accept_callback));
 106         m_socket_server.signal_connect_receive(slot(this, &EcoreSocketPanelAgent::socket_receive_callback));
 107         m_socket_server.signal_connect_exception(slot(this, &EcoreSocketPanelAgent::socket_exception_callback));
 108     }
 109
 110     ~EcoreSocketPanelAgent() {
 111         for (unsigned int ii = 0; ii < _read_handler_list.size(); ++ii) {
 112             ecore_main_fd_handler_del(_read_handler_list[ii]);
 113         }
 114         _read_handler_list.clear();
 115     }
 116
 117     bool initialize(InfoManager* info_manager, const String& display, bool resident) {
 118         LOGD ("");
 119         m_info_manager = info_manager;
 120         m_socket_address = scim_get_default_panel_socket_address(display);
 121
 122         m_socket_server.shutdown();
 123
 124         if (m_socket_server.create(SocketAddress(m_socket_address))) {
 125             Ecore_Fd_Handler* panel_agent_read_handler = NULL;
 126             panel_agent_read_handler = ecore_main_fd_handler_add(get_server_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
 127             _read_handler_list.push_back(panel_agent_read_handler);
 128             return true;
 129         }
 130         LOGE("create server failed\n");
 131         return false;
 132     }
 133
 134     bool valid(void) const {
 135         return m_socket_server.valid();
 136     }
 137
 138     void stop(void) {
 139         SCIM_DEBUG_MAIN(1) << "PanelAgent::stop ()\n";
 140         LOGD ("");
 141         lock();
 142         m_should_exit = true;
 143         unlock();
 144         SocketClient  client;
 145         if (client.connect(SocketAddress(m_socket_address))) {
 146             client.close();
 147         }
 148     }
 149 private:
 150     void update_panel_event(int client, uint32 context_id, int cmd, uint32 nType, uint32 nValue) {
 151         LOGD ("client id:%d\n", client);
 152         Socket client_socket(client);
 153         m_send_trans.clear();
 154         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 155         m_send_trans.put_data(context_id);
 156         m_send_trans.put_command(cmd);
 157         m_send_trans.put_data(nType);
 158         m_send_trans.put_data(nValue);
 159         m_send_trans.write_to_socket(client_socket);
 160     }
 161
 162     void move_preedit_caret(int client, uint32 context_id, uint32 position) {
 163         SCIM_DEBUG_MAIN(1) << "PanelAgent::move_preedit_caret (" << position << ")\n";
 164         LOGD ("client id:%d\n", client);
 165         Socket client_socket(client);
 166         m_send_trans.clear();
 167         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 168         m_send_trans.put_data((uint32) context_id);
 169         m_send_trans.put_command(SCIM_TRANS_CMD_MOVE_PREEDIT_CARET);
 170         m_send_trans.put_data((uint32) position);
 171         m_send_trans.write_to_socket(client_socket);
 172     }
 173
 174 //useless
 175 #if 0
 176     void request_help(int client_id, uint32 context_id) {
 177         SCIM_DEBUG_MAIN(1) << "PanelAgent::request_help ()\n";
 178         LOGD ("client id:%d", client_id);
 179
 180         Socket client_socket(client_id);
 181         m_send_trans.clear();
 182         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 183         m_send_trans.put_data((uint32) context_id);
 184         m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_REQUEST_HELP);
 185         m_send_trans.write_to_socket(client_socket);
 186
 187     }
 188
 189     void request_factory_menu(int client_id, uint32 context_id) {
 190         LOGD ("client id:%d", client_id);
 191         Socket client_socket(client_id);
 192         m_send_trans.clear();
 193         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 194         m_send_trans.put_data((uint32) context_id);
 195         m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_REQUEST_FACTORY_MENU);
 196         m_send_trans.write_to_socket(client_socket);
 197     }
 198 #endif
 199
 200     void reset_keyboard_ise(int client, uint32 context_id) {
 201         LOGD ("client id:%d\n", client);
 202         Socket client_socket(client);
 203         m_send_trans.clear();
 204         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 205         m_send_trans.put_data((uint32) context_id);
 206         m_send_trans.put_command(ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE);
 207         m_send_trans.write_to_socket(client_socket);
 208     }
 209
 210     void update_keyboard_ise_list(int client, uint32 context) {
 211         LOGD ("client id:%d\n", client);
 212
 213         Socket client_socket(client);
 214         m_send_trans.clear();
 215         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 216         m_send_trans.put_data((uint32) context);
 217         m_send_trans.put_command(ISM_TRANS_CMD_PANEL_UPDATE_KEYBOARD_ISE);
 218         m_send_trans.write_to_socket(client_socket);
 219     }
 220
 221     void change_factory(int client, uint32 context, const String&  uuid) {
 222         SCIM_DEBUG_MAIN(1) << "PanelAgent::change_factory (" << uuid << ")\n";
 223         LOGD ("client id:%d\n", client);
 224
 225         Socket client_socket(client);
 226         m_send_trans.clear();
 227         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 228         m_send_trans.put_data((uint32) context);
 229         m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_CHANGE_FACTORY);
 230         m_send_trans.put_data(uuid);
 231         m_send_trans.write_to_socket(client_socket);
 232     }
 233
 234     void helper_candidate_show(int client, uint32 context, const String&  uuid) {
 235         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 236         LOGD ("client id:%d\n", client);
 237
 238
 239         Socket client_socket(client);
 240
 241         m_send_trans.clear();
 242         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 243         m_send_trans.put_data(context);
 244         m_send_trans.put_data(uuid);
 245         m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_SHOW);
 246         m_send_trans.write_to_socket(client_socket);
 247     }
 248
 249     void helper_candidate_hide(int client, uint32 context, const String&  uuid) {
 250         LOGD ("client id:%d\n", client);
 251
 252         Socket client_socket(client);
 253
 254         m_send_trans.clear();
 255         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 256         m_send_trans.put_data(context);
 257         m_send_trans.put_data(uuid);
 258         m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_HIDE);
 259         m_send_trans.write_to_socket(client_socket);
 260     }
 261
 262     void candidate_more_window_show(int client, uint32 context) {
 263         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 264         LOGD ("client id:%d\n", client);
 265
 266
 267         Socket client_socket(client);
 268
 269         m_send_trans.clear();
 270         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 271         m_send_trans.put_data(context);
 272         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 273             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 274         m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_SHOW);
 275         m_send_trans.write_to_socket(client_socket);
 276     }
 277
 278     void candidate_more_window_hide(int client, uint32 context) {
 279         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 280         LOGD ("client id:%d\n", client);
 281
 282         Socket client_socket(client);
 283
 284         m_send_trans.clear();
 285         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 286         m_send_trans.put_data(context);
 287         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 288             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 289         m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_HIDE);
 290         m_send_trans.write_to_socket(client_socket);
 291     }
 292
 293     void update_helper_lookup_table(int client, uint32 context, const String& uuid, const LookupTable& table) {
 294         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 295         LOGD ("client id:%d\n", client);
 296
 297         Socket client_socket(client);
 298
 299         m_send_trans.clear();
 300         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 301         m_send_trans.put_data(context);
 302         m_send_trans.put_data(uuid);
 303         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_LOOKUP_TABLE);
 304         m_send_trans.put_data(table);
 305         m_send_trans.write_to_socket(client_socket);
 306     }
 307
 308     void select_aux(int client, uint32 contextid, uint32 item) {
 309         SCIM_DEBUG_MAIN(1) << "PanelAgent::select_aux (" << item << ")\n";
 310         LOGD ("client id:%d\n", client);
 311
 312         Socket client_socket(client);
 313         m_send_trans.clear();
 314         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 315         m_send_trans.put_data((uint32) contextid);
 316
 317         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 318             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 319
 320         m_send_trans.put_command(ISM_TRANS_CMD_SELECT_AUX);
 321         m_send_trans.put_data((uint32)item);
 322         m_send_trans.write_to_socket(client_socket);
 323     }
 324
 325     void select_candidate(int client, uint32 context, uint32 item) {
 326         LOGD ("client id:%d\n", client);
 327
 328         Socket client_socket(client);
 329         m_send_trans.clear();
 330         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 331         m_send_trans.put_data((uint32) context);
 332
 333         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 334             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 335
 336         m_send_trans.put_command(SCIM_TRANS_CMD_SELECT_CANDIDATE);
 337         m_send_trans.put_data((uint32)item);
 338         m_send_trans.write_to_socket(client_socket);
 339     }
 340
 341     void lookup_table_page_up(int client, uint32 context) {
 342         SCIM_DEBUG_MAIN(1) << "PanelAgent::lookup_table_page_up ()\n";
 343         LOGD ("client id:%d\n", client);
 344
 345         Socket client_socket(client);
 346         m_send_trans.clear();
 347         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 348         m_send_trans.put_data((uint32) context);
 349
 350         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 351             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 352
 353         m_send_trans.put_command(SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_UP);
 354         m_send_trans.write_to_socket(client_socket);
 355     }
 356
 357     void lookup_table_page_down(int client, uint32 context) {
 358         LOGD ("client id:%d\n", client);
 359
 360         Socket client_socket(client);
 361         m_send_trans.clear();
 362         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 363         m_send_trans.put_data((uint32) context);
 364
 365         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 366             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 367
 368         m_send_trans.put_command(SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_DOWN);
 369         m_send_trans.write_to_socket(client_socket);
 370     }
 371
 372     void update_lookup_table_page_size(int client, uint32 context, uint32 size) {
 373         LOGD ("client id:%d\n", client);
 374
 375         Socket client_socket(client);
 376         m_send_trans.clear();
 377         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 378         m_send_trans.put_data((uint32) context);
 379
 380         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 381             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 382
 383         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE_PAGE_SIZE);
 384         m_send_trans.put_data(size);
 385         m_send_trans.write_to_socket(client_socket);
 386     }
 387
 388     void update_candidate_item_layout(int client, uint32 context, const std::vector<uint32>& row_items) {
 389         LOGD ("client id:%d\n", client);
 390
 391         Socket client_socket(client);
 392         m_send_trans.clear();
 393         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 394         m_send_trans.put_data((uint32) context);
 395
 396         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 397             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 398
 399         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_ITEM_LAYOUT);
 400         m_send_trans.put_data(row_items);
 401         m_send_trans.write_to_socket(client_socket);
 402     }
 403
 404     void select_associate(int client, uint32 context, uint32 item) {
 405         LOGD ("client id:%d\n", client);
 406
 407         Socket client_socket(client);
 408         m_send_trans.clear();
 409         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 410         m_send_trans.put_data((uint32) context);
 411
 412         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 413             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 414
 415         m_send_trans.put_command(ISM_TRANS_CMD_SELECT_ASSOCIATE);
 416         m_send_trans.put_data((uint32)item);
 417         m_send_trans.write_to_socket(client_socket);
 418     }
 419
 420     void associate_table_page_up(int client, uint32 context) {
 421         LOGD ("client id:%d\n", client);
 422
 423         Socket client_socket(client);
 424         m_send_trans.clear();
 425         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 426         m_send_trans.put_data((uint32) context);
 427
 428         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 429             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 430
 431         m_send_trans.put_command(ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_UP);
 432         m_send_trans.write_to_socket(client_socket);
 433     }
 434
 435     void associate_table_page_down(int client, uint32 context) {
 436         LOGD ("client id:%d\n", client);
 437
 438         Socket client_socket(client);
 439         m_send_trans.clear();
 440         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 441         m_send_trans.put_data((uint32) context);
 442
 443         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 444             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 445
 446         m_send_trans.put_command(ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_DOWN);
 447         m_send_trans.write_to_socket(client_socket);
 448     }
 449
 450     void update_associate_table_page_size(int client, uint32 context, uint32 size) {
 451         LOGD ("client id:%d\n", client);
 452
 453         Socket client_socket(client);
 454         m_send_trans.clear();
 455         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 456         m_send_trans.put_data((uint32) context);
 457
 458         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 459             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 460
 461         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE_PAGE_SIZE);
 462         m_send_trans.put_data(size);
 463         m_send_trans.write_to_socket(client_socket);
 464     }
 465
 466     void update_displayed_candidate_number(int client, uint32 context, uint32 size) {
 467         LOGD ("client id:%d\n", client);
 468
 469         Socket client_socket(client);
 470         m_send_trans.clear();
 471         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 472         m_send_trans.put_data((uint32) context);
 473
 474         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 475             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 476
 477         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_DISPLAYED_CANDIDATE);
 478         m_send_trans.put_data(size);
 479         m_send_trans.write_to_socket(client_socket);
 480     }
 481
 482     void send_longpress_event(int client, uint32 context, int index) {
 483         LOGD ("client id:%d\n", client);
 484
 485         Socket client_socket(client);
 486         m_send_trans.clear();
 487         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 488         m_send_trans.put_data((uint32) context);
 489
 490         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 491             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 492
 493         m_send_trans.put_command(ISM_TRANS_CMD_LONGPRESS_CANDIDATE);
 494         m_send_trans.put_data(index);
 495         m_send_trans.write_to_socket(client_socket);
 496     }
 497
 498     void trigger_property(int client, uint32 context, const String&  property) {
 499         LOGD ("client id:%d\n", client);
 500
 501         Socket client_socket(client);
 502         m_send_trans.clear();
 503         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 504         m_send_trans.put_data((uint32) context);
 505
 506         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 507             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 508
 509         m_send_trans.put_command(SCIM_TRANS_CMD_TRIGGER_PROPERTY);
 510         m_send_trans.put_data(property);
 511         m_send_trans.write_to_socket(client_socket);
 512     }
 513
 514     void focus_out_helper(int client, uint32 context, const String& uuid) {
 515         LOGD ("client id:%d\n", client);
 516
 517         Socket client_socket(client);
 518         m_send_trans.clear();
 519         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 520         m_send_trans.put_data(context);
 521         m_send_trans.put_data(uuid);
 522         m_send_trans.put_command(SCIM_TRANS_CMD_FOCUS_OUT);
 523         m_send_trans.write_to_socket(client_socket);
 524     }
 525
 526     void focus_in_helper(int client, uint32 context, const String& uuid) {
 527         LOGD ("client id:%d\n", client);
 528
 529         Socket client_socket(client);
 530         m_send_trans.clear();
 531         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 532         m_send_trans.put_data(context);
 533         m_send_trans.put_data(uuid);
 534         m_send_trans.put_command(SCIM_TRANS_CMD_FOCUS_IN);
 535         m_send_trans.write_to_socket(client_socket);
 536     }
 537
 538     void show_helper(int client, uint32 context, const String& uuid, char* data, size_t& len) {
 539         LOGD ("client id:%d\n", client);
 540
 541         Socket client_socket(client);
 542         m_send_trans.clear();
 543         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 544         m_send_trans.put_data(context);
 545         m_send_trans.put_data(uuid);
 546         m_send_trans.put_command(ISM_TRANS_CMD_SHOW_ISE_PANEL);
 547         m_send_trans.put_data(data, len);
 548         m_send_trans.write_to_socket(client_socket);
 549     }
 550
 551     void hide_helper(int client, uint32 context, const String& uuid) {
 552         LOGD ("client id:%d\n", client);
 553
 554         Socket client_socket(client);
 555         m_send_trans.clear();
 556         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 557         m_send_trans.put_data(context);
 558         m_send_trans.put_data(uuid);
 559         m_send_trans.put_command(ISM_TRANS_CMD_HIDE_ISE_PANEL);
 560         m_send_trans.write_to_socket(client_socket);
 561     }
 562
 563     void set_helper_mode(int client, uint32 context, const String& uuid, uint32& mode) {
 564         LOGD ("client id:%d\n", client);
 565
 566         Socket client_socket(client);
 567         m_send_trans.clear();
 568         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 569         m_send_trans.put_data(context);
 570         m_send_trans.put_data(uuid);
 571         m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_MODE);
 572         m_send_trans.put_data(mode);
 573         m_send_trans.write_to_socket(client_socket);
 574     }
 575
 576     void set_helper_language(int client, uint32 context, const String& uuid, uint32& language) {
 577         LOGD ("client id:%d\n", client);
 578
 579         Socket client_socket(client);
 580         m_send_trans.clear();
 581         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 582         m_send_trans.put_data(context);
 583         m_send_trans.put_data(uuid);
 584         m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_LANGUAGE);
 585         m_send_trans.put_data(language);
 586         m_send_trans.write_to_socket(client_socket);
 587     }
 588
 589     void set_helper_imdata(int client, uint32 context, const String& uuid, char* imdata, size_t& len) {
 590         LOGD ("client id:%d\n", client);
 591
 592         Socket client_socket(client);
 593         m_send_trans.clear();
 594         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 595         m_send_trans.put_data(context);
 596         m_send_trans.put_data(uuid);
 597         m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_IMDATA);
 598         m_send_trans.put_data(imdata, len);
 599         m_send_trans.write_to_socket(client_socket);
 600     }
 601
 602     void set_helper_return_key_type(int client, uint32 context, const String& uuid, uint32 type) {
 603         LOGD ("client id:%d\n", client);
 604
 605         Socket client_socket(client);
 606         m_send_trans.clear();
 607         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 608         m_send_trans.put_data(context);
 609         m_send_trans.put_data(uuid);
 610         m_send_trans.put_command(ISM_TRANS_CMD_SET_RETURN_KEY_TYPE);
 611         m_send_trans.put_data(type);
 612         m_send_trans.write_to_socket(client_socket);
 613     }
 614
 615     void get_helper_return_key_type(int client, uint32 context, const String& uuid, _OUT_ uint32& type) {
 616         LOGD ("client id:%d\n", client);
 617
 618         Socket client_socket(client);
 619         Transaction trans;
 620         trans.clear();
 621         trans.put_command(SCIM_TRANS_CMD_REPLY);
 622         trans.put_data(context);
 623         trans.put_data(uuid);
 624         trans.put_command(ISM_TRANS_CMD_GET_RETURN_KEY_TYPE);
 625
 626         int cmd;
 627
 628         if (trans.write_to_socket(client_socket)
 629             && trans.read_from_socket(client_socket)
 630             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 631             && trans.get_data(type)) {
 632             SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
 633
 634         } else {
 635             LOGW ("read failed\n");
 636         }
 637     }
 638
 639     void set_helper_return_key_disable(int client, uint32 context, const String& uuid, uint32 disabled) {
 640         LOGD ("client id:%d\n", client);
 641
 642         Socket client_socket(client);
 643         m_send_trans.clear();
 644         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 645         m_send_trans.put_data(context);
 646         m_send_trans.put_data(uuid);
 647         m_send_trans.put_command(ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE);
 648         m_send_trans.put_data(disabled);
 649         m_send_trans.write_to_socket(client_socket);
 650     }
 651
 652     void get_helper_return_key_disable(int client, uint32 context, const String& uuid, _OUT_ uint32& disabled) {
 653
 654         Socket client_socket(client);
 655         LOGD ("client id:%d", client);
 656
 657         Transaction trans;
 658
 659         trans.clear();
 660         trans.put_command(SCIM_TRANS_CMD_REPLY);
 661         trans.put_data(context);
 662         trans.put_data(uuid);
 663         trans.put_command(ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE);
 664
 665         int cmd;
 666
 667         if (trans.write_to_socket(client_socket)
 668             && trans.read_from_socket(client_socket)
 669             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 670             && trans.get_data(disabled)) {
 671             SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
 672
 673         } else {
 674             LOGW ("read failed");
 675         }
 676     }
 677
 678     void set_helper_layout(int client, uint32 context, const String& uuid, uint32& layout) {
 679         LOGD ("client id:%d\n", client);
 680
 681         Socket client_socket(client);
 682         m_send_trans.clear();
 683         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 684         m_send_trans.put_data(context);
 685         m_send_trans.put_data(uuid);
 686         m_send_trans.put_command(ISM_TRANS_CMD_SET_LAYOUT);
 687         m_send_trans.put_data(layout);
 688         m_send_trans.write_to_socket(client_socket);
 689     }
 690
 691     void set_helper_input_mode(int client, uint32 context, const String& uuid, uint32& mode) {
 692         LOGD ("client id:%d\n", client);
 693
 694         Socket client_socket(client);
 695         m_send_trans.clear();
 696         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 697         m_send_trans.put_data(context);
 698         m_send_trans.put_data(uuid);
 699         m_send_trans.put_command(ISM_TRANS_CMD_SET_INPUT_MODE);
 700         m_send_trans.put_data(mode);
 701         m_send_trans.write_to_socket(client_socket);
 702     }
 703
 704     void set_helper_input_hint(int client, uint32 context, const String& uuid, uint32& hint) {
 705         LOGD ("client id:%d\n", client);
 706
 707         Socket client_socket(client);
 708         m_send_trans.clear();
 709         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 710         m_send_trans.put_data(context);
 711         m_send_trans.put_data(uuid);
 712         m_send_trans.put_command(ISM_TRANS_CMD_SET_INPUT_HINT);
 713         m_send_trans.put_data(hint);
 714         m_send_trans.write_to_socket(client_socket);
 715     }
 716
 717     void set_helper_bidi_direction(int client, uint32 context, const String& uuid, uint32& direction) {
 718         LOGD ("client id:%d\n", client);
 719
 720         Socket client_socket(client);
 721         m_send_trans.clear();
 722         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 723         m_send_trans.put_data(context);
 724         m_send_trans.put_data(uuid);
 725         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION);
 726         m_send_trans.put_data(direction);
 727         m_send_trans.write_to_socket(client_socket);
 728     }
 729
 730     void set_helper_caps_mode(int client, uint32 context, const String& uuid, uint32& mode) {
 731         LOGD ("client id:%d\n", client);
 732
 733         Socket client_socket(client);
 734         m_send_trans.clear();
 735         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 736         m_send_trans.put_data(context);
 737         m_send_trans.put_data(uuid);
 738         m_send_trans.put_command(ISM_TRANS_CMD_SET_CAPS_MODE);
 739         m_send_trans.put_data(mode);
 740         m_send_trans.write_to_socket(client_socket);
 741     }
 742
 743     void show_helper_option_window(int client, uint32 context, const String& uuid) {
 744         LOGD ("client id:%d\n", client);
 745
 746         Socket client_socket(client);
 747         m_send_trans.clear();
 748         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 749         m_send_trans.put_data(context);
 750         m_send_trans.put_data(uuid);
 751         m_send_trans.put_command(ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW);
 752         m_send_trans.write_to_socket(client_socket);
 753     }
 754
 755     bool process_key_event(int client, uint32 context, const String& uuid, KeyEvent& key, _OUT_ uint32& result) {
 756         LOGD ("client id:%d\n", client);
 757
 758         Socket client_socket(client);
 759
 760         Transaction trans;
 761
 762         trans.clear();
 763         trans.put_command(SCIM_TRANS_CMD_REPLY);
 764         trans.put_data(context);
 765         trans.put_data(uuid);
 766         trans.put_command(SCIM_TRANS_CMD_PROCESS_KEY_EVENT);
 767         trans.put_data(key);
 768         int cmd;
 769
 770         if (trans.write_to_socket(client_socket)
 771             && trans.read_from_socket(client_socket)
 772             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 773             && trans.get_data(result)) {
 774             SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
 775             return true;
 776         } else {
 777             LOGW ("read failed\n");
 778         }
 779
 780         return false;
 781     }
 782
 783     bool get_helper_geometry(int client, uint32 context, String& uuid, _OUT_ struct rectinfo& info) {
 784         LOGD ("client id:%d\n", client);
 785
 786         Socket client_socket(client);
 787
 788         Transaction trans;
 789         trans.clear();
 790         trans.put_command(SCIM_TRANS_CMD_REPLY);
 791         trans.put_data(context);
 792         trans.put_data(uuid);
 793         trans.put_command(ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY);
 794
 795         if (trans.write_to_socket(client_socket)) {
 796             int cmd;
 797
 798             trans.clear();
 799
 800             if (trans.read_from_socket(client_socket)
 801                 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 802                 && trans.get_data(info.pos_x)
 803                 && trans.get_data(info.pos_y)
 804                 && trans.get_data(info.width)
 805                 && trans.get_data(info.height)) {
 806                 SCIM_DEBUG_MAIN(1) << __func__ << " is successful\n";
 807                 return true;
 808             } else
 809                 LOGW ("read failed\n");
 810         } else
 811             LOGW ("write failed\n");
 812
 813         return false;
 814     }
 815
 816     void get_helper_imdata(int client, uint32 context, String& uuid, char** imdata, size_t& len) {
 817         LOGD ("client id:%d\n", client);
 818
 819         Socket client_socket(client);
 820
 821         Transaction trans;
 822         trans.clear();
 823         trans.put_command(SCIM_TRANS_CMD_REPLY);
 824         trans.put_data(context);
 825         trans.put_data(uuid);
 826         trans.put_command(ISM_TRANS_CMD_GET_ISE_IMDATA);
 827
 828         int cmd;
 829
 830         if (trans.write_to_socket(client_socket)
 831             && trans.read_from_socket(client_socket)
 832             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 833             && trans.get_data(imdata, len)) {
 834             SCIM_DEBUG_MAIN(1) << "get_helper_imdata success\n";
 835         } else {
 836             LOGW ("read failed\n");
 837         }
 838     }
 839
 840     void get_helper_layout(int client, uint32 context, String& uuid, uint32& layout) {
 841         LOGD ("client id:%d\n", client);
 842
 843         Socket client_socket(client);
 844
 845         Transaction trans;
 846         trans.clear();
 847         trans.put_command(SCIM_TRANS_CMD_REPLY);
 848         trans.put_data(context);
 849         trans.put_data(uuid);
 850         trans.put_command(ISM_TRANS_CMD_GET_LAYOUT);
 851
 852         int cmd;
 853
 854         if (trans.write_to_socket(client_socket)
 855             && trans.read_from_socket(client_socket)
 856             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 857             && trans.get_data(layout)) {
 858             SCIM_DEBUG_MAIN(1) << "get_helper_layout success\n";
 859         } else
 860             LOGW ("failed\n");
 861     }
 862
 863     void get_ise_language_locale(int client, uint32 context, String& uuid, char* data,  size_t& len) {
 864         SCIM_DEBUG_MAIN(4) << __func__ << "\n";
 865         LOGD ("client id:%d\n", client);
 866
 867         Transaction trans;
 868
 869         trans.clear();
 870         trans.put_command(SCIM_TRANS_CMD_REPLY);
 871         trans.put_data(context);
 872         trans.put_data(uuid);
 873         trans.put_command(ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE);
 874
 875         int cmd;
 876         Socket client_socket(client);
 877
 878         if (trans.write_to_socket(client_socket)
 879             && trans.read_from_socket(client_socket)
 880             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 881             && trans.get_data(&data, len)) {
 882         } else {
 883             LOGW ("failed\n");
 884         }
 885     }
 886
 887     void check_option_window(int client, uint32 context, String& uuid, _OUT_ uint32& avail) {
 888         LOGD ("client id:%d\n", client);
 889
 890         int cmd;
 891         Socket client_socket(client);
 892
 893         Transaction trans;
 894
 895         trans.clear();
 896         trans.put_command(SCIM_TRANS_CMD_REPLY);
 897         trans.put_data(context);
 898         trans.put_data(uuid);
 899         trans.put_command(ISM_TRANS_CMD_CHECK_OPTION_WINDOW);
 900         trans.write_to_socket(client_socket);
 901
 902         if (!trans.read_from_socket(client_socket, m_socket_timeout) ||
 903             !trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REPLY ||
 904             !trans.get_data(avail)) {
 905             LOGW ("ISM_TRANS_CMD_CHECK_OPTION_WINDOW failed\n");
 906         }
 907     }
 908
 909     void reset_ise_option(int client, uint32 context) {
 910         LOGD ("client id:%d\n", client);
 911
 912         Socket client_socket(client);
 913         m_send_trans.clear();
 914         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 915         m_send_trans.put_data((uint32) context);
 916         m_send_trans.put_command(ISM_TRANS_CMD_RESET_ISE_OPTION);
 917         m_send_trans.write_to_socket(client_socket);
 918     }
 919
 920     void reset_helper_context(int client, uint32 context, const String& uuid) {
 921         LOGD ("client id:%d\n", client);
 922
 923         Socket client_socket(client);
 924         m_send_trans.clear();
 925         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 926         m_send_trans.put_data(context);
 927         m_send_trans.put_data(uuid);
 928         m_send_trans.put_command(ISM_TRANS_CMD_RESET_ISE_CONTEXT);
 929         m_send_trans.write_to_socket(client_socket);
 930     }
 931
 932     void reload_config(int client) {
 933         SCIM_DEBUG_MAIN(1) << "PanelAgent::reload_config ()\n";
 934         LOGD ("client id:%d\n", client);
 935
 936         m_send_trans.clear();
 937         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 938         m_send_trans.put_command(SCIM_TRANS_CMD_RELOAD_CONFIG);
 939
 940         Socket client_socket(client);
 941         m_send_trans.write_to_socket(client_socket);
 942     }
 943
 944     void exit(int client, uint32 context) {
 945         SCIM_DEBUG_MAIN(1) << "PanelAgent::exit ()\n";
 946         LOGD ("client id:%d\n", client);
 947
 948         m_send_trans.clear();
 949         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 950
 951         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 952             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 953
 954         m_send_trans.put_command(SCIM_TRANS_CMD_EXIT);
 955
 956         Socket client_socket(client);
 957         m_send_trans.write_to_socket(client_socket);
 958     }
 959
 960     void socket_update_surrounding_text(int client, uint32 context, const String& uuid, String& text, uint32 cursor) {
 961         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 962         LOGD ("client id:%d\n", client);
 963
 964         Socket client_socket(client);
 965
 966         m_send_trans.clear();
 967         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 968         m_send_trans.put_data(context);
 969         m_send_trans.put_data(uuid);
 970         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT);
 971         m_send_trans.put_data(text);
 972         m_send_trans.put_data(cursor);
 973         m_send_trans.write_to_socket(client_socket);
 974     }
 975
 976     void socket_update_selection(int client, uint32 context, const String& uuid, String text) {
 977         LOGD ("client id:%d\n", client);
 978
 979         Socket client_socket(client);
 980
 981         m_send_trans.clear();
 982         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 983         m_send_trans.put_data(context);
 984         m_send_trans.put_data(uuid);
 985         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SELECTION);
 986         m_send_trans.put_data(text);
 987         m_send_trans.write_to_socket(client_socket);
 988     }
 989
 990     void socket_get_keyboard_ise_list(int client, uint32 context, const String& uuid, std::vector<String>& list) {
 991         LOGD ("client id:%d\n", client);
 992
 993         Socket socket_client(client);
 994         m_send_trans.clear();
 995         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 996         m_send_trans.put_data(context);
 997         m_send_trans.put_data(uuid);
 998         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE_LIST);
 999         m_send_trans.put_data(list.size());
1000
1001         for (unsigned int i = 0; i < list.size(); i++)
1002             m_send_trans.put_data(list[i]);
1003
1004         m_send_trans.write_to_socket(socket_client);
1005     }
1006
1007     void socket_get_candidate_ui(int client, uint32 context, const String& uuid,  int style,  int mode) {
1008         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_get_candidate_ui ()\n";
1009
1010         LOGD ("client id:%d\n", client);
1011
1012         Socket socket_client(client);
1013         m_send_trans.clear();
1014         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1015         m_send_trans.put_data(context);
1016         m_send_trans.put_data(uuid);
1017         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_UI);
1018         m_send_trans.put_data(style);
1019         m_send_trans.put_data(mode);
1020         m_send_trans.write_to_socket(socket_client);
1021     }
1022
1023     void socket_get_candidate_geometry(int client, uint32 context, const String& uuid, struct rectinfo& info) {
1024         SCIM_DEBUG_MAIN(4) << __func__ << " \n";
1025
1026         LOGD ("client id:%d\n", client);
1027
1028         Socket socket_client(client);
1029         m_send_trans.clear();
1030         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1031         m_send_trans.put_data(context);
1032         m_send_trans.put_data(uuid);
1033         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_GEOMETRY);
1034         m_send_trans.put_data(info.pos_x);
1035         m_send_trans.put_data(info.pos_y);
1036         m_send_trans.put_data(info.width);
1037         m_send_trans.put_data(info.height);
1038         m_send_trans.write_to_socket(socket_client);
1039     }
1040
1041     void socket_get_keyboard_ise(int client, uint32 context, const String& uuid, String& ise_name, String& ise_uuid) {
1042         LOGD ("client id:%d\n", client);
1043
1044         Socket socket_client(client);
1045         m_send_trans.clear();
1046         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1047         m_send_trans.put_data(context);
1048         m_send_trans.put_data(uuid);
1049         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE);
1050         m_send_trans.put_data(ise_name);
1051         m_send_trans.put_data(ise_uuid);
1052         m_send_trans.write_to_socket(socket_client);
1053     }
1054
1055     void socket_start_helper(int client, uint32 context, const String& ic_uuid) {
1056         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_start_helper ()\n";
1057
1058         LOGD ("client id:%d\n", client);
1059
1060         Socket client_socket(client);
1061         m_send_trans.clear();
1062         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1063         m_send_trans.put_data(context);
1064         m_send_trans.put_data(ic_uuid);
1065         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1066         m_send_trans.write_to_socket(client_socket);
1067     }
1068
1069     void helper_detach_input_context(int client, uint32 context, const String& ic_uuid) {
1070         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_stop_helper ()\n";
1071
1072         LOGD ("client id:%d\n", client);
1073
1074         Socket client_socket(client);
1075         m_send_trans.clear();
1076         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1077         m_send_trans.put_data(context);
1078         m_send_trans.put_data(ic_uuid);
1079         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_DETACH_INPUT_CONTEXT);
1080         m_send_trans.write_to_socket(client_socket);
1081     }
1082
1083     void helper_process_imengine_event(int client, uint32 context, const String& ic_uuid, const Transaction& _nest_trans) {
1084         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_send_helper_event ()\n";
1085         LOGD ("client id:%d\n", client);
1086
1087         Socket client_socket(client);
1088
1089         lock();
1090
1091         m_send_trans.clear();
1092         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1093
1094         /* FIXME: We presume that client and context are both less than 65536.
1095          * Hopefully, it should be true in any UNIXs.
1096          * So it's ok to combine client and context into one uint32. */
1097         m_send_trans.put_data(context);
1098         m_send_trans.put_data(ic_uuid);
1099         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_PROCESS_IMENGINE_EVENT);
1100         m_send_trans.put_data(_nest_trans);
1101         m_send_trans.write_to_socket(client_socket);
1102
1103         unlock();
1104     }
1105
1106     void process_helper_event(int client, uint32 context, String target_uuid, String active_uuid, Transaction& nest_trans) {
1107         LOGD ("client id:%d\n", client);
1108
1109         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_helper_send_imengine_event (" << client << ")\n";
1110         Socket socket_client(client);
1111         lock();
1112         m_send_trans.clear();
1113         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1114         m_send_trans.put_data(context);
1115         m_send_trans.put_command(SCIM_TRANS_CMD_PROCESS_HELPER_EVENT);
1116         m_send_trans.put_data(target_uuid);
1117         m_send_trans.put_data(active_uuid);
1118         m_send_trans.put_data(nest_trans);
1119         m_send_trans.write_to_socket(socket_client);
1120         unlock();
1121
1122     }
1123
1124     void socket_helper_key_event(int client, uint32 context, int cmd, KeyEvent& key) {
1125         LOGD ("client id:%d\n", client);
1126
1127         Socket socket_client(client);
1128         lock();
1129         m_send_trans.clear();
1130         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1131         m_send_trans.put_data(context);
1132         m_send_trans.put_command(cmd);
1133         m_send_trans.put_data(key);
1134         m_send_trans.write_to_socket(socket_client);
1135         unlock();
1136     }
1137
1138     void commit_string(int client, uint32 target_context, const WideString& wstr) {
1139         LOGD ("client id:%d\n", client);
1140
1141         Socket socket_client(client);
1142         lock();
1143         m_send_trans.clear();
1144         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1145         m_send_trans.put_data(target_context);
1146         m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_STRING);
1147         m_send_trans.put_data(wstr);
1148         m_send_trans.write_to_socket(socket_client);
1149         unlock();
1150     }
1151
1152     void socket_helper_get_surrounding_text(int client, uint32 context_id, uint32 maxlen_before, uint32 maxlen_after) {
1153         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1154         LOGD ("client id:%d\n", client);
1155
1156         Socket socket_client(client);
1157         lock();
1158         m_send_trans.clear();
1159         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1160         m_send_trans.put_data(context_id);
1161         m_send_trans.put_command(SCIM_TRANS_CMD_GET_SURROUNDING_TEXT);
1162         m_send_trans.put_data(maxlen_before);
1163         m_send_trans.put_data(maxlen_after);
1164         m_send_trans.write_to_socket(socket_client);
1165         unlock();
1166     }
1167
1168     void socket_helper_delete_surrounding_text(int client, uint32 context_id, uint32 offset, uint32 len) {
1169         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1170         LOGD ("client id:%d\n", client);
1171
1172         Socket socket_client(client);
1173         lock();
1174         m_send_trans.clear();
1175         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1176         m_send_trans.put_data(context_id);
1177         m_send_trans.put_command(SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT);
1178         m_send_trans.put_data(offset);
1179         m_send_trans.put_data(len);
1180         m_send_trans.write_to_socket(socket_client);
1181         unlock();
1182     }
1183
1184     void socket_helper_get_selection(int client, uint32 context_id) {
1185         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1186         LOGD ("client id:%d\n", client);
1187
1188
1189         Socket socket_client(client);
1190         lock();
1191         m_send_trans.clear();
1192         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1193         m_send_trans.put_data(context_id);
1194         m_send_trans.put_command(SCIM_TRANS_CMD_GET_SELECTION);
1195         m_send_trans.write_to_socket(socket_client);
1196         unlock();
1197     }
1198
1199     void socket_helper_set_selection(int client, uint32 context_id, uint32 start, uint32 end) {
1200         LOGD ("client id:%d\n", client);
1201
1202         Socket socket_client(client);
1203         lock();
1204         m_send_trans.clear();
1205         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1206         m_send_trans.put_data(context_id);
1207         m_send_trans.put_command(SCIM_TRANS_CMD_SET_SELECTION);
1208         m_send_trans.put_data(start);
1209         m_send_trans.put_data(end);
1210         m_send_trans.write_to_socket(socket_client);
1211         unlock();
1212     }
1213
1214     void show_preedit_string(int client, uint32  target_context) {
1215         LOGD ("client id:%d\n", client);
1216
1217         Socket socket_client(client);
1218         lock();
1219         m_send_trans.clear();
1220         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1221         m_send_trans.put_data(target_context);
1222         m_send_trans.put_command(SCIM_TRANS_CMD_SHOW_PREEDIT_STRING);
1223         m_send_trans.write_to_socket(socket_client);
1224         unlock();
1225     }
1226
1227     void hide_preedit_string(int client, uint32  target_context) {
1228         LOGD ("client id:%d\n", client);
1229
1230         Socket socket_client(client);
1231         lock();
1232         m_send_trans.clear();
1233         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1234         m_send_trans.put_data(target_context);
1235         m_send_trans.put_command(SCIM_TRANS_CMD_HIDE_PREEDIT_STRING);
1236         m_send_trans.write_to_socket(socket_client);
1237         unlock();
1238     }
1239
1240     void update_preedit_string(int client, uint32  target_context, WideString wstr, AttributeList& attrs, uint32 caret) {
1241         LOGD ("client id:%d\n", client);
1242
1243         Socket socket_client(client);
1244         lock();
1245         m_send_trans.clear();
1246         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1247         m_send_trans.put_data(target_context);
1248         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
1249         m_send_trans.put_data(wstr);
1250         m_send_trans.put_data(attrs);
1251         m_send_trans.put_data(caret);
1252         m_send_trans.write_to_socket(socket_client);
1253         unlock();
1254
1255     }
1256
1257     void update_preedit_caret(int client, uint32 focused_context, uint32 caret) {
1258
1259         LOGD ("client id:%d\n", client);
1260
1261         Socket socket_client(client);
1262         lock();
1263         m_send_trans.clear();
1264         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1265         m_send_trans.put_data(focused_context);
1266         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET);
1267         m_send_trans.put_data(caret);
1268         m_send_trans.write_to_socket(socket_client);
1269         unlock();
1270
1271     }
1272
1273     void helper_attach_input_context_and_update_screen(int client, std::vector < std::pair <uint32, String> >& helper_ic_index, uint32 current_screen) {
1274         LOGD ("client id:%d\n", client);
1275
1276         Socket socket_client(client);
1277         m_send_trans.clear();
1278         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1279         m_send_trans.put_command(SCIM_TRANS_CMD_OK);
1280         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1281
1282         for (size_t i = 0; i < helper_ic_index.size(); ++i) {
1283             m_send_trans.put_data(helper_ic_index[i].first);
1284             m_send_trans.put_data(helper_ic_index[i].second);
1285         }
1286
1287         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1288         m_send_trans.put_data((uint32)current_screen);
1289         m_send_trans.write_to_socket(socket_client);
1290     }
1291
1292     void update_ise_input_context(int client, uint32 focused_context, uint32 type, uint32 value) {
1293         LOGD ("client id:%d\n", client);
1294
1295         Socket client_socket(client);
1296         m_send_trans.clear();
1297         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1298         m_send_trans.put_data(focused_context);
1299         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT);
1300         m_send_trans.put_data(type);
1301         m_send_trans.put_data(value);
1302         m_send_trans.write_to_socket(client_socket);
1303
1304     }
1305
1306     void send_private_command(int client, uint32 focused_context, String command) {
1307         LOGD ("client id:%d\n", client);
1308
1309         Socket socket_client(client);
1310         lock();
1311         m_send_trans.clear();
1312         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1313         m_send_trans.put_data(focused_context);
1314         m_send_trans.put_command(SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND);
1315         m_send_trans.put_data(command);
1316         m_send_trans.write_to_socket(socket_client);
1317
1318     }
1319
1320
1321     void helper_all_update_spot_location(int client, uint32 context_id, String uuid, int x, int y) {
1322         LOGD ("client id:%d\n", client);
1323
1324         m_send_trans.clear();
1325         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1326
1327         /* FIXME: We presume that client and context are both less than 65536.
1328          * Hopefully, it should be true in any UNIXs.
1329          * So it's ok to combine client and context into one uint32. */
1330         m_send_trans.put_data(context_id);
1331         m_send_trans.put_data(uuid);
1332         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION);
1333         m_send_trans.put_data((uint32) x);
1334         m_send_trans.put_data((uint32) y);
1335
1336         Socket client_socket(client);
1337         m_send_trans.write_to_socket(client_socket);
1338
1339     }
1340
1341     void helper_all_update_cursor_position(int client, uint32 context_id, String uuid, int cursor_pos) {
1342         LOGD ("client id:%d\n", client);
1343
1344         m_send_trans.clear();
1345         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1346         m_send_trans.put_data(context_id);
1347         m_send_trans.put_data(uuid);
1348         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CURSOR_POSITION);
1349         m_send_trans.put_data((uint32) cursor_pos);
1350
1351         Socket client_socket(client);
1352         m_send_trans.write_to_socket(client_socket);
1353
1354     }
1355
1356     void helper_all_update_screen(int client, uint32 context_id, String uuid, int screen) {
1357         LOGD ("client id:%d\n", client);
1358
1359         m_send_trans.clear();
1360         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1361
1362         /* FIXME: We presume that client and context are both less than 65536.
1363          * Hopefully, it should be true in any UNIXs.
1364          * So it's ok to combine client and context into one uint32. */
1365         m_send_trans.put_data(context_id);
1366         m_send_trans.put_data(uuid);
1367         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1368         m_send_trans.put_data((uint32) screen);
1369
1370         Socket client_socket(client);
1371         m_send_trans.write_to_socket(client_socket);
1372
1373     }
1374
1375 private:
1376
1377     static void send_fail_reply (int client_id)
1378     {
1379         Socket client_socket (client_id);
1380         Transaction trans;
1381         trans.clear ();
1382         trans.put_command (SCIM_TRANS_CMD_REPLY);
1383         trans.put_command (SCIM_TRANS_CMD_FAIL);
1384         trans.write_to_socket (client_socket);
1385     }
1386
1387     bool filter_event(int fd) {
1388         SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_event ()\n";
1389
1390         return m_socket_server.filter_event(fd);
1391     }
1392
1393     bool filter_exception_event(int fd) {
1394         SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_exception_event ()\n";
1395
1396         return m_socket_server.filter_exception_event(fd);
1397     }
1398
1399     int get_server_id() {
1400         SCIM_DEBUG_MAIN(1) << "PanelAgent::get_server_id ()\n";
1401
1402         return m_socket_server.get_id();
1403     }
1404
1405     bool socket_check_client_connection(const Socket& client) {
1406         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_check_client_connection (" << client.get_id() << ")\n";
1407
1408         unsigned char buf [sizeof(uint32)];
1409
1410         int nbytes = client.read_with_timeout(buf, sizeof(uint32), m_socket_timeout);
1411
1412         if (nbytes == sizeof(uint32))
1413             return true;
1414
1415         if (nbytes < 0) {
1416             LOGW ("Error occurred when reading socket: %s\n", client.get_error_message().c_str());
1417         } else {
1418             LOGW ("Timeout when reading socket\n");
1419         }
1420
1421         return false;
1422     }
1423
1424     /**
1425      * @brief Callback function for ecore fd handler.
1426      *
1427      * @param data The data to pass to this callback.
1428      * @param fd_handler The ecore fd handler.
1429      *
1430      * @return ECORE_CALLBACK_RENEW
1431      */
1432     static Eina_Bool panel_agent_handler(void* data, Ecore_Fd_Handler* fd_handler) {
1433         if (fd_handler == NULL || data == NULL)
1434             return ECORE_CALLBACK_RENEW;
1435
1436         EcoreSocketPanelAgent* _agent = (EcoreSocketPanelAgent*)data;
1437
1438         int fd = ecore_main_fd_handler_fd_get(fd_handler);
1439
1440         for (unsigned int i = 0; i < _agent->_read_handler_list.size(); i++) {
1441             if (fd_handler == _agent->_read_handler_list [i]) {
1442                 if (!_agent->filter_event(fd)) {
1443                     std::cerr << "_panel_agent->filter_event () is failed!!!\n";
1444                     ecore_main_fd_handler_del(fd_handler);
1445
1446                     ISF_SAVE_LOG("_panel_agent->filter_event (fd=%d) is failed!!!\n", fd);
1447                 }
1448
1449                 return ECORE_CALLBACK_RENEW;
1450             }
1451         }
1452
1453         std::cerr << "panel_agent_handler () has received exception event!!!\n";
1454         _agent->filter_exception_event(fd);
1455         ecore_main_fd_handler_del(fd_handler);
1456
1457         ISF_SAVE_LOG("Received exception event (fd=%d)!!!\n", fd);
1458         return ECORE_CALLBACK_RENEW;
1459     }
1460
1461     void socket_accept_callback(SocketServer*   server,
1462                                 const Socket&   client) {
1463         SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_accept_callback (" << client.get_id() << ")\n";
1464         LOGD ("");
1465         lock();
1466
1467         if (m_should_exit) {
1468             SCIM_DEBUG_MAIN(3) << "Exit Socket Server Thread.\n";
1469             server->shutdown();
1470         } else {
1471             //m_signal_accept_connection (client.get_id ());
1472             Ecore_Fd_Handler* panel_agent_read_handler = ecore_main_fd_handler_add(client.get_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
1473             _read_handler_list.push_back(panel_agent_read_handler);
1474         }
1475
1476         unlock();
1477     }
1478
1479     void socket_receive_callback(SocketServer*   server,
1480                                  const Socket&   client) {
1481         int     client_id = client.get_id();
1482         int     cmd     = 0;
1483         uint32  key     = 0;
1484         uint32  context = 0;
1485         String  uuid;
1486
1487         ClientInfo client_info;
1488
1489         SCIM_DEBUG_MAIN(1) << "PanelAgent::socket_receive_callback (" << client_id << ")\n";
1490
1491         /* If the connection is closed then close this client. */
1492         if (!socket_check_client_connection(client)) {
1493             LOGW ("check client connection failed\n");
1494             socket_close_connection(server, client);
1495             return;
1496         }
1497
1498         client_info = m_info_manager->socket_get_client_info(client_id);
1499
1500         /* If it's a new client, then request to open the connection first. */
1501         if (client_info.type == UNKNOWN_CLIENT) {
1502             socket_open_connection(server, client);
1503             return;
1504         }
1505
1506         /* If can not read the transaction,
1507          * or the transaction is not started with SCIM_TRANS_CMD_REQUEST,
1508          * or the key is mismatch,
1509          * just return. */
1510         if (!m_recv_trans.read_from_socket(client, m_socket_timeout) ||
1511             !m_recv_trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REQUEST ||
1512             !m_recv_trans.get_data(key)    || key != (uint32) client_info.key) {
1513             LOGW ("cmd:%d key:%d client info key: %d\n", cmd, key, client_info.key);
1514             return;
1515         }
1516
1517         if (client_info.type == FRONTEND_ACT_CLIENT) {
1518             if (m_recv_trans.get_data(context)) {
1519                 SCIM_DEBUG_MAIN(1) << "PanelAgent::FrontEnd Client, context = " << context << "\n";
1520                 socket_transaction_start();
1521
1522                 while (m_recv_trans.get_command(cmd)) {
1523                     LOGD ("PanelAgent::cmd = %d\n", cmd);
1524
1525                     if (cmd == ISM_TRANS_CMD_REGISTER_PANEL_CLIENT) {
1526                         uint32 id = 0;
1527
1528                         if (m_recv_trans.get_data(id)) {
1529                             m_info_manager->register_panel_client(client_id, id);
1530                         } else {
1531                             LOGW ("wrong format of transaction\n");
1532                         }
1533
1534                         continue;
1535                     }
1536
1537                     else if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_INPUT_CONTEXT) {
1538                         if (m_recv_trans.get_data(uuid)) {
1539                             m_info_manager->register_input_context(client_id, context, uuid);
1540                         } else {
1541                             LOGW ("wrong format of transaction\n");
1542                         }
1543
1544                         continue;
1545                     }
1546
1547                     else if (cmd == SCIM_TRANS_CMD_PANEL_REMOVE_INPUT_CONTEXT) {
1548                         m_info_manager->remove_input_context(client_id, context);
1549                         continue;
1550                     }
1551
1552                     else if (cmd == SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT) {
1553                         m_info_manager->socket_reset_input_context(client_id, context);
1554                         continue;
1555                     }
1556
1557                     else if (cmd == SCIM_TRANS_CMD_FOCUS_IN) {
1558                         SCIM_DEBUG_MAIN(4) << "    SCIM_TRANS_CMD_FOCUS_IN (" << "client:" << client_id << " context:" << context << ")\n";
1559
1560                         if (m_recv_trans.get_data(uuid)) {
1561                             m_info_manager->focus_in(client_id, context, uuid);
1562                         } else {
1563                             LOGW ("wrong format of transaction\n");
1564                         }
1565
1566                         continue;
1567                     }
1568
1569                     else if (cmd == ISM_TRANS_CMD_TURN_ON_LOG) {
1570                         uint32 isOn;
1571
1572                         if (m_recv_trans.get_data(isOn)) {
1573                             m_info_manager->socket_turn_on_log(isOn);
1574                         } else {
1575                             LOGW ("wrong format of transaction\n");
1576                         }
1577
1578                         continue;
1579                     }
1580
1581                     else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
1582                         m_info_manager->show_isf_panel(client_id);
1583                         continue;
1584                     } else if (cmd == ISM_TRANS_CMD_HIDE_ISF_CONTROL) {
1585                         m_info_manager->hide_isf_panel(client_id);
1586                         continue;
1587                     } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_PANEL) {
1588                         uint32 client;
1589                         uint32 context;
1590                         char*   data = NULL;
1591                         size_t  len;
1592                         bool ret = false;
1593
1594                         if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context) && m_recv_trans.get_data(&data, len)) {
1595                             ret = true;
1596                         } else {
1597                             LOGW ("wrong format of transaction\n");
1598                         }
1599
1600                         Transaction trans;
1601                         Socket client_socket(client_id);
1602
1603                         trans.clear();
1604                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1605                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
1606                         trans.put_data(ret);
1607                         trans.write_to_socket(client_socket);
1608
1609                         if (data != NULL)
1610                             delete[] data;
1611
1612                         if (ret)
1613                             m_info_manager->show_ise_panel(client_id, client, context, data, len);
1614
1615                         continue;
1616                     } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
1617                         uint32 client;
1618                         uint32 context;
1619
1620                         if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context)) {
1621                             m_info_manager->hide_ise_panel(client_id, client, context);
1622                         } else {
1623                             LOGW ("wrong format of transaction\n");
1624                         }
1625
1626                         continue;
1627                     } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY) {
1628                         struct rectinfo info;
1629                         m_info_manager->get_input_panel_geometry(client_id, info);
1630                         Transaction trans;
1631                         Socket client_socket(client_id);
1632
1633                         trans.clear();
1634                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1635                         trans.put_command(SCIM_TRANS_CMD_OK);
1636                         trans.put_data(info.pos_x);
1637                         trans.put_data(info.pos_y);
1638                         trans.put_data(info.width);
1639                         trans.put_data(info.height);
1640                         trans.write_to_socket(client_socket);
1641                         continue;
1642                     } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
1643                         struct rectinfo info;
1644                         m_info_manager->get_candidate_window_geometry(client_id, info);
1645                         Transaction trans;
1646                         Socket client_socket(client_id);
1647
1648                         trans.clear();
1649                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1650                         trans.put_command(SCIM_TRANS_CMD_OK);
1651                         trans.put_data(info.pos_x);
1652                         trans.put_data(info.pos_y);
1653                         trans.put_data(info.width);
1654                         trans.put_data(info.height);
1655                         trans.write_to_socket(client_socket);
1656                         continue;
1657                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE) {
1658                         size_t  len;
1659                         char*   data = NULL;
1660                         m_info_manager->get_ise_language_locale(client_id, data, len);
1661                         Transaction trans;
1662                         trans.clear();
1663                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1664
1665                         if (data != NULL && len > 0) {
1666                             trans.put_command(SCIM_TRANS_CMD_OK);
1667                             trans.put_data(data, len);
1668                         } else {
1669                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1670                         }
1671
1672                         Socket client_socket(client_id);
1673                         trans.write_to_socket(client_socket);
1674
1675                         if (NULL != data)
1676                             delete [] data;
1677
1678                         continue;
1679                     } else if (cmd == ISM_TRANS_CMD_SET_ISE_LANGUAGE) {
1680                         uint32 language;
1681
1682                         if (m_recv_trans.get_data(language)) {
1683                             m_info_manager->set_ise_language(client_id, language);
1684                         } else {
1685                             LOGW ("wrong format of transaction\n");
1686                         }
1687
1688                         continue;
1689                     } else if (cmd == ISM_TRANS_CMD_SET_ISE_IMDATA) {
1690                         char*   imdata = NULL;
1691                         size_t  len;
1692
1693                         if (m_recv_trans.get_data(&imdata, len)) {
1694                             m_info_manager->set_ise_imdata(client_id, imdata, len);
1695                         } else {
1696                             LOGW ("wrong format of transaction\n");
1697                         }
1698
1699                         if (NULL != imdata)
1700                             delete [] imdata;
1701
1702                         continue;
1703                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_IMDATA) {
1704                         char*   imdata = NULL;
1705                         size_t  len = 0;
1706                         m_info_manager->get_ise_imdata(client_id, &imdata, len);
1707                         Transaction trans;
1708                         Socket client_socket(client_id);
1709
1710                         trans.clear();
1711                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1712
1713                         if (len) {
1714                             trans.put_command(SCIM_TRANS_CMD_OK);
1715                             trans.put_data(imdata, len);
1716                         } else {
1717                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1718                         }
1719
1720                         trans.write_to_socket(client_socket);
1721
1722                         if (NULL != imdata)
1723                             delete [] imdata;
1724
1725                         continue;
1726                     } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_TYPE) {
1727                         uint32 type;
1728
1729                         if (m_recv_trans.get_data(type)) {
1730                             m_info_manager->set_ise_return_key_type(client_id, type);
1731                         } else {
1732                             LOGW ("wrong format of transaction\n");
1733                         }
1734
1735                         continue;
1736                     } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_TYPE) {
1737                         uint32 type;
1738                         bool ret = m_info_manager->get_ise_return_key_type(client_id, type);
1739                         Transaction trans;
1740                         Socket client_socket(client_id);
1741
1742                         trans.clear();
1743                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1744
1745                         if (ret) {
1746                             trans.put_command(SCIM_TRANS_CMD_OK);
1747                             trans.put_data(type);
1748                         } else {
1749                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1750                         }
1751
1752                         trans.write_to_socket(client_socket);
1753                         continue;
1754                     } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE) {
1755                         uint32 disabled;
1756
1757                         if (m_recv_trans.get_data(disabled)) {
1758                             m_info_manager->set_ise_return_key_disable(client_id, disabled);
1759                         } else {
1760                             LOGW ("wrong format of transaction\n");
1761                         }
1762
1763                         continue;
1764                     } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE) {
1765                         uint32 disabled;
1766                         bool ret = true;
1767                         m_info_manager->get_ise_return_key_disable(client_id, disabled);
1768                         Transaction trans;
1769                         Socket client_socket(client_id);
1770
1771                         trans.clear();
1772                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1773
1774                         if (ret) {
1775                             trans.put_command(SCIM_TRANS_CMD_OK);
1776                             trans.put_data(disabled);
1777                         } else {
1778                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1779                         }
1780
1781                         trans.write_to_socket(client_socket);
1782                         continue;
1783                     } else if (cmd == ISM_TRANS_CMD_GET_LAYOUT) {
1784                         uint32 layout;
1785                         bool ret = m_info_manager->get_ise_layout(client_id, layout);
1786                         Transaction trans;
1787                         Socket client_socket(client_id);
1788
1789                         trans.clear();
1790                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1791
1792                         if (ret) {
1793                             trans.put_command(SCIM_TRANS_CMD_OK);
1794                             trans.put_data(layout);
1795                         } else {
1796                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1797                         }
1798
1799                         trans.write_to_socket(client_socket);
1800                         continue;
1801                     } else if (cmd == ISM_TRANS_CMD_SET_LAYOUT) {
1802                         uint32 layout;
1803
1804                         if (m_recv_trans.get_data(layout)) {
1805                             m_info_manager->set_ise_layout(client_id, layout);
1806                         } else {
1807                             LOGW ("wrong format of transaction\n");
1808                         }
1809
1810                         continue;
1811                     } else if (cmd == ISM_TRANS_CMD_SET_CAPS_MODE) {
1812                         uint32 mode;
1813
1814                         if (m_recv_trans.get_data(mode)) {
1815                             m_info_manager->set_ise_caps_mode(client_id, mode);
1816                         } else {
1817                             LOGW ("wrong format of transaction\n");
1818                         }
1819
1820                         continue;
1821                     } else if (cmd == ISM_TRANS_CMD_SEND_WILL_SHOW_ACK) {
1822                         m_info_manager->will_show_ack(client_id);
1823                         continue;
1824                     } else if (cmd == ISM_TRANS_CMD_SEND_WILL_HIDE_ACK) {
1825                         m_info_manager->will_hide_ack(client_id);
1826                         continue;
1827                     } else if (cmd == ISM_TRANS_CMD_SET_HARDWARE_KEYBOARD_MODE) {
1828                         uint32 mode;
1829
1830                         if (m_recv_trans.get_data(mode)) {
1831                             m_info_manager->set_keyboard_mode(client_id, mode);
1832                         } else {
1833                             LOGW ("wrong format of transaction\n");
1834                         }
1835
1836                         continue;
1837                     } else if (cmd == ISM_TRANS_CMD_SEND_CANDIDATE_WILL_HIDE_ACK) {
1838                         m_info_manager->candidate_will_hide_ack(client_id);
1839                         continue;
1840                     } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT) {
1841                         uint32 result = 0;
1842                         bool   ret      = false;
1843
1844                         KeyEvent key;
1845
1846                         if (m_recv_trans.get_data(key)) {
1847                             ret      = true;
1848                             m_info_manager->process_key_event(key, result);
1849                         } else {
1850                             LOGW ("wrong format of transaction\n");
1851                         }
1852
1853                         Transaction trans;
1854                         Socket client_socket(client_id);
1855
1856                         trans.clear();
1857                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1858
1859                         if (ret) {
1860                             trans.put_command(SCIM_TRANS_CMD_OK);
1861                             trans.put_data(result);
1862                         } else {
1863                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1864                         }
1865
1866                         trans.write_to_socket(client_socket);
1867                         continue;
1868                     } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_HELPER_OPTION) {
1869                         uint32 option;
1870                         m_info_manager->get_active_helper_option(client_id, option);
1871                         Transaction trans;
1872                         Socket client_socket(client_id);
1873
1874                         trans.clear();
1875                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1876                         trans.put_command(SCIM_TRANS_CMD_OK);
1877                         trans.put_data(option);
1878                         SCIM_DEBUG_MAIN(4) << __func__ << " option " << option << "\n";
1879                         trans.write_to_socket(client_socket);
1880                         continue;
1881                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_STATE) {
1882                         int state = 0;
1883                         m_info_manager->get_ise_state(client_id, state);
1884                         Transaction trans;
1885                         Socket client_socket(client_id);
1886
1887                         trans.clear();
1888                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1889                         trans.put_command(SCIM_TRANS_CMD_OK);
1890                         trans.put_data(state);
1891                         trans.write_to_socket(client_socket);
1892                         continue;
1893                     } else if (cmd == ISM_TRANS_CMD_SET_INPUT_MODE) {
1894                         uint32 input_mode;
1895
1896                         if (m_recv_trans.get_data(input_mode)) {
1897                             m_info_manager->set_ise_input_mode(client_id, input_mode);
1898                         } else {
1899                             LOGW ("wrong format of transaction\n");
1900                         }
1901
1902                         continue;
1903                     } else if (cmd == ISM_TRANS_CMD_SET_INPUT_HINT) {
1904                         uint32 input_hint;
1905
1906                         if (m_recv_trans.get_data(input_hint)) {
1907                             m_info_manager->set_ise_input_hint(client_id, input_hint);
1908                         } else {
1909                             LOGW ("wrong format of transaction\n");
1910                         }
1911
1912                         continue;
1913                     } else if (cmd == ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION) {
1914                         uint32 bidi_direction;
1915
1916                         if (m_recv_trans.get_data(bidi_direction)) {
1917                             m_info_manager->update_ise_bidi_direction(client_id, bidi_direction);
1918                         } else {
1919                             LOGW ("wrong format of transaction\n");
1920                         }
1921
1922                         continue;
1923                     } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
1924                         m_info_manager->show_ise_option_window(client_id);
1925                         continue;
1926                     }
1927
1928                     //FIXME
1929                     //skip data
1930
1931                     else if (cmd == SCIM_TRANS_CMD_START_HELPER) {
1932                         String uuid;
1933
1934                         if (m_recv_trans.get_data(uuid) && uuid.length()) {
1935                             m_info_manager->socket_start_helper(client_id, context, uuid);
1936                         } else {
1937                             LOGW ("wrong format of transaction\n");
1938                         }
1939
1940                         continue;
1941                     } else if (cmd == SCIM_TRANS_CMD_SEND_HELPER_EVENT) {
1942                         String uuid;
1943
1944                         if (m_recv_trans.get_data(uuid) && m_recv_trans.get_data(m_nest_trans) &&
1945                             uuid.length() && m_nest_trans.valid()) {
1946                             m_info_manager->socket_send_helper_event(client_id, context, uuid, m_nest_trans);
1947                         } else {
1948                             LOGW ("wrong format of transaction\n");
1949                         }
1950
1951                         continue;
1952                     } else if (cmd == SCIM_TRANS_CMD_STOP_HELPER) {
1953                         String uuid;
1954
1955                         if (m_recv_trans.get_data(uuid) && uuid.length()) {
1956                             m_info_manager->socket_stop_helper(client_id, context, uuid);
1957                         } else {
1958                             LOGW ("wrong format of transaction\n");
1959                         }
1960
1961                         continue;
1962                     }
1963
1964                     //FIXME
1965                     //skip data
1966
1967                     /* Client must focus in before do any other things. */
1968                     else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_ON)
1969                         m_info_manager->socket_turn_on();
1970                     else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_OFF)
1971                         m_info_manager->socket_turn_off();
1972                     else if (cmd == SCIM_TRANS_CMD_UPDATE_SCREEN) {
1973                         uint32 num;
1974
1975                         if (m_recv_trans.get_data(num))
1976                             m_info_manager->socket_update_screen(client_id, num);
1977                         else
1978                             LOGW ("wrong format of transaction\n");
1979                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION) {
1980                         uint32 x, y, top_y;
1981
1982                         if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) && m_recv_trans.get_data(top_y)) {
1983                             m_info_manager->socket_update_spot_location(x, y, top_y);
1984                         } else {
1985                             LOGW ("wrong format of transaction\n");
1986                         }
1987                     } else if (cmd == ISM_TRANS_CMD_UPDATE_CURSOR_POSITION) {
1988                         uint32 cursor_pos;
1989
1990                         if (m_recv_trans.get_data(cursor_pos)) {
1991                             m_info_manager->socket_update_cursor_position(cursor_pos);
1992                         } else {
1993                             LOGW ("wrong format of transaction\n");
1994                         }
1995                     } else if (cmd == ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT) {
1996                         String text;
1997                         uint32 cursor;
1998
1999                         if (m_recv_trans.get_data(text) && m_recv_trans.get_data(cursor)) {
2000                             m_info_manager->socket_update_surrounding_text(text, cursor);
2001                         } else {
2002                             LOGW ("wrong format of transaction\n");
2003                         }
2004                     } else if (cmd == ISM_TRANS_CMD_UPDATE_SELECTION) {
2005                         String text;
2006
2007                         if (m_recv_trans.get_data(text)) {
2008                             m_info_manager->socket_update_selection(text);
2009                         } else {
2010                             LOGW ("wrong format of transaction\n");
2011                         }
2012                     } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE)
2013                         m_info_manager->expand_candidate();
2014                     else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE)
2015                         m_info_manager->contract_candidate();
2016                     else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2017                         uint32 portrait_line, mode;
2018
2019                         if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2020                             m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2021                         else
2022                             LOGW ("wrong format of transaction\n");
2023                     } else if (cmd == SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO) {
2024                         PanelFactoryInfo info;
2025
2026                         if (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2027                             m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2028                             m_info_manager->socket_update_factory_info(info);
2029                         } else {
2030                             LOGW ("wrong format of transaction\n");
2031                         }
2032                     } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING)
2033                         m_info_manager->socket_show_preedit_string();
2034                     else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING)
2035                         m_info_manager->socket_show_aux_string();
2036                     else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE)
2037                         m_info_manager->socket_show_lookup_table();
2038                     else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE)
2039                         m_info_manager->socket_show_associate_table();
2040                     else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING)
2041                         m_info_manager->socket_hide_preedit_string();
2042                     else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING)
2043                         m_info_manager->socket_hide_aux_string();
2044                     else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE)
2045                         m_info_manager->socket_hide_lookup_table();
2046                     else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE)
2047                         m_info_manager->socket_hide_associate_table();
2048                     else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2049                         String str;
2050                         AttributeList attrs;
2051                         uint32 caret;
2052
2053                         if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs) && m_recv_trans.get_data(caret))
2054                             m_info_manager->socket_update_preedit_string(str, attrs, caret);
2055                         else
2056                             LOGW ("wrong format of transaction\n");
2057                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2058                         uint32 caret;
2059
2060                         if (m_recv_trans.get_data(caret))
2061                             m_info_manager->socket_update_preedit_caret(caret);
2062                         else
2063                             LOGW ("wrong format of transaction\n");
2064                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2065                         String str;
2066                         AttributeList attrs;
2067
2068                         if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2069                             m_info_manager->socket_update_aux_string(str, attrs);
2070                         else
2071                             LOGW ("wrong format of transaction\n");
2072                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2073                         CommonLookupTable _isf_candidate_table;
2074
2075                         if (m_recv_trans.get_data(_isf_candidate_table))
2076                             m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2077                         else
2078                             LOGW ("wrong format of transaction\n");
2079
2080                     } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2081                         CommonLookupTable table;
2082
2083                         if (m_recv_trans.get_data(table))
2084                             m_info_manager->socket_update_associate_table(table);
2085                         else
2086                             LOGW ("wrong format of transaction\n");
2087                     } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2088                         PropertyList properties;
2089
2090                         if (m_recv_trans.get_data(properties))
2091                             m_info_manager->socket_register_properties(properties);
2092                         else
2093                             LOGW ("wrong format of transaction\n");
2094                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2095                         Property property;
2096
2097                         if (m_recv_trans.get_data(property))
2098                             m_info_manager->socket_update_property(property);
2099                         else
2100                             LOGW ("wrong format of transaction\n");
2101                     } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_HELP) {
2102                         String help;
2103
2104                         if (m_recv_trans.get_data(help))
2105                             m_info_manager->socket_show_help(help);
2106                         else
2107                             LOGW ("wrong format of transaction\n");
2108                     } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU) {
2109                         PanelFactoryInfo info;
2110                         std::vector <PanelFactoryInfo> vec;
2111
2112                         while (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2113                                m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2114                             info.lang = scim_get_normalized_language(info.lang);
2115                             vec.push_back(info);
2116                         }
2117
2118                         m_info_manager->socket_show_factory_menu(vec);
2119                     } else if (cmd == SCIM_TRANS_CMD_FOCUS_OUT) {
2120                         m_info_manager->focus_out(client_id, context);
2121                     } else {
2122                         LOGW ("unknow cmd: %d\n", cmd);
2123                     }
2124                 }
2125
2126                 socket_transaction_end();
2127             }
2128         } else if (client_info.type == FRONTEND_CLIENT) {
2129             if (m_recv_trans.get_data(context)) {
2130                 SCIM_DEBUG_MAIN(1) << "client_info.type == FRONTEND_CLIENT\n";
2131                 socket_transaction_start();
2132
2133                 while (m_recv_trans.get_command(cmd)) {
2134                     LOGD ("PanelAgent::cmd = %d\n", cmd);
2135
2136                     if (cmd == ISM_TRANS_CMD_GET_PANEL_CLIENT_ID) {
2137                         Socket client_socket(client_id);
2138
2139                         Transaction trans;
2140                         trans.clear();
2141                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2142                         trans.put_command(SCIM_TRANS_CMD_OK);
2143                         trans.put_data(client_id);
2144                         trans.write_to_socket(client_socket);
2145                         continue;
2146                     } else {
2147                         LOGW ("unknow cmd: %d\n", cmd);
2148                     }
2149                 }
2150
2151                 socket_transaction_end();
2152             }
2153         } else if (client_info.type == HELPER_CLIENT) {
2154             socket_transaction_start();
2155
2156             while (m_recv_trans.get_command(cmd)) {
2157                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2158
2159                 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_HELPER) {
2160                     HelperInfo info;
2161
2162                     if (m_recv_trans.get_data(info.uuid) &&
2163                         m_recv_trans.get_data(info.name) &&
2164                         m_recv_trans.get_data(info.icon) &&
2165                         m_recv_trans.get_data(info.description) &&
2166                         m_recv_trans.get_data(info.option) &&
2167                         info.uuid.length()) {
2168                         m_info_manager->socket_helper_register_helper(client_id, info);
2169                     }
2170                 } else {
2171                     LOGW ("unknow cmd: %d\n", cmd);
2172                 }
2173             }
2174
2175             socket_transaction_end();
2176         } else if (client_info.type == HELPER_ACT_CLIENT) {
2177             socket_transaction_start();
2178
2179             while (m_recv_trans.get_command(cmd)) {
2180                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2181
2182                 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER) {
2183                     HelperInfo info;
2184
2185                     if (m_recv_trans.get_data(info.uuid) &&
2186                         m_recv_trans.get_data(info.name) &&
2187                         m_recv_trans.get_data(info.icon) &&
2188                         m_recv_trans.get_data(info.description) &&
2189                         m_recv_trans.get_data(info.option) &&
2190                         info.uuid.length()) {
2191                         m_info_manager->socket_helper_register_helper_passive(client_id, info);
2192                     } else {
2193                         LOGW ("wrong format of transaction\n");
2194                     }
2195                 } else if (cmd == SCIM_TRANS_CMD_COMMIT_STRING) {
2196                     uint32 target_ic;
2197                     String target_uuid;
2198                     WideString wstr;
2199
2200                     if (m_recv_trans.get_data(target_ic)    &&
2201                         m_recv_trans.get_data(target_uuid)  &&
2202                         m_recv_trans.get_data(wstr)         &&
2203                         wstr.length()) {
2204                         m_info_manager->socket_helper_commit_string(client_id, target_ic, target_uuid, wstr);
2205                     } else {
2206                         LOGW ("wrong format of transaction\n");
2207                     }
2208                 } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING) {
2209                     uint32 target_ic;
2210                     String target_uuid;
2211
2212                     if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2213                         m_info_manager->socket_helper_show_preedit_string(client_id, target_ic, target_uuid);
2214                     } else {
2215                         LOGW ("wrong format of transaction\n");
2216                     }
2217                 } else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING) {
2218                     m_info_manager->socket_show_aux_string();
2219                 } else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE) {
2220                     m_info_manager->socket_show_lookup_table();
2221                 } else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE) {
2222                     m_info_manager->socket_show_associate_table();
2223                 } else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING) {
2224                     uint32 target_ic;
2225                     String target_uuid;
2226
2227                     if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2228                         m_info_manager->socket_helper_hide_preedit_string(client_id, target_ic, target_uuid);
2229                     } else {
2230                         LOGW ("wrong format of transaction\n");
2231                     }
2232                 } else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING) {
2233                     m_info_manager->socket_hide_aux_string();
2234                 } else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE) {
2235                     m_info_manager->socket_hide_lookup_table();
2236                 } else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE) {
2237                     m_info_manager->socket_hide_associate_table();
2238                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2239                     uint32 target_ic;
2240                     String target_uuid;
2241                     WideString wstr;
2242                     AttributeList attrs;
2243                     uint32 caret;
2244
2245                     if (m_recv_trans.get_data(target_ic)    &&
2246                         m_recv_trans.get_data(target_uuid)  &&
2247                         m_recv_trans.get_data(wstr) &&
2248                         m_recv_trans.get_data(attrs) &&
2249                         m_recv_trans.get_data(caret)) {
2250                         m_info_manager->socket_helper_update_preedit_string(client_id, target_ic, target_uuid, wstr, attrs, caret);
2251                     } else {
2252                         LOGW ("wrong format of transaction\n");
2253                     }
2254                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2255                     uint32 caret;
2256
2257                     if (m_recv_trans.get_data(caret)) {
2258                         m_info_manager->socket_helper_update_preedit_caret(client_id, caret);
2259                     } else {
2260                         LOGW ("wrong format of transaction\n");
2261                     }
2262                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2263                     String str;
2264                     AttributeList attrs;
2265
2266                     if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2267                         m_info_manager->socket_update_aux_string(str, attrs);
2268                     else
2269                         LOGW ("wrong format of transaction\n");
2270
2271                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2272                     CommonLookupTable _isf_candidate_table;
2273
2274                     if (m_recv_trans.get_data(_isf_candidate_table)) {
2275                         m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2276                     } else {
2277                         LOGW ("wrong format of transaction\n");
2278                     }
2279                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2280                     CommonLookupTable _isf_candidate_table;
2281
2282                     if (m_recv_trans.get_data(_isf_candidate_table)) {
2283                         m_info_manager->socket_update_associate_table(_isf_candidate_table);
2284                     } else {
2285                         LOGW ("wrong format of transaction\n");
2286                     }
2287                 } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT ||
2288                            cmd == SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT) {
2289                     uint32 target_ic;
2290                     String target_uuid;
2291                     KeyEvent key;
2292
2293                     if (m_recv_trans.get_data(target_ic)    &&
2294                         m_recv_trans.get_data(target_uuid)  &&
2295                         m_recv_trans.get_data(key)          &&
2296                         !key.empty()) {
2297                         m_info_manager->socket_helper_send_key_event(client_id, target_ic, target_uuid, key);
2298                     } else {
2299                         LOGW ("wrong format of transaction\n");
2300                     }
2301                 } else if (cmd == SCIM_TRANS_CMD_FORWARD_KEY_EVENT) {
2302                     uint32 target_ic;
2303                     String target_uuid;
2304                     KeyEvent key;
2305
2306                     if (m_recv_trans.get_data(target_ic)    &&
2307                         m_recv_trans.get_data(target_uuid)  &&
2308                         m_recv_trans.get_data(key)          &&
2309                         !key.empty()) {
2310                         m_info_manager->socket_helper_forward_key_event(client_id, target_ic, target_uuid, key);
2311                     } else {
2312                         LOGW ("wrong format of transaction\n");
2313                     }
2314                 } else if (cmd == SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT) {
2315                     uint32 target_ic;
2316                     String target_uuid;
2317
2318                     if (m_recv_trans.get_data(target_ic)    &&
2319                         m_recv_trans.get_data(target_uuid)  &&
2320                         m_recv_trans.get_data(m_nest_trans) &&
2321                         m_nest_trans.valid()) {
2322                         m_info_manager->socket_helper_send_imengine_event(client_id, target_ic, target_uuid, m_nest_trans);
2323                     } else {
2324                         LOGW ("wrong format of transaction\n");
2325                     }
2326                 } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2327                     PropertyList properties;
2328
2329                     if (m_recv_trans.get_data(properties))
2330                         m_info_manager->socket_helper_register_properties(client_id, properties);
2331                     else
2332                         LOGW ("wrong format of transaction\n");
2333                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2334                     Property property;
2335
2336                     if (m_recv_trans.get_data(property))
2337                         m_info_manager->socket_helper_update_property(client_id, property);
2338                     else
2339                         LOGW ("wrong format of transaction\n");
2340                 } else if (cmd == SCIM_TRANS_CMD_RELOAD_CONFIG) {
2341                     m_info_manager->reload_config();
2342                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT) {
2343                     uint32 type;
2344                     uint32 value;
2345
2346                     if (m_recv_trans.get_data(type) && m_recv_trans.get_data(value)) {
2347                         m_info_manager->socket_helper_update_input_context(client_id, type, value);
2348                     } else {
2349                         LOGW ("wrong format of transaction\n");
2350                     }
2351                 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST) {
2352                     String uuid;
2353
2354                     if (m_recv_trans.get_data(uuid)) {
2355                         m_info_manager->socket_get_keyboard_ise_list(uuid);
2356                     } else {
2357                         LOGW ("wrong format of transaction\n");
2358                     }
2359                 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2360                     uint32 portrait_line, mode;
2361
2362                     if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2363                         m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2364                     else
2365                         LOGW ("wrong format of transaction\n");
2366                 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_UI) {
2367                     String uuid;
2368
2369                     if (m_recv_trans.get_data(uuid)) {
2370                         m_info_manager->socket_get_candidate_ui(uuid);
2371                     } else {
2372                         LOGW ("wrong format of transaction\n");
2373                     }
2374                 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_POSITION) {
2375                     uint32 left, top;
2376
2377                     if (m_recv_trans.get_data(left) && m_recv_trans.get_data(top))
2378                         m_info_manager->socket_set_candidate_position(left, top);
2379                     else
2380                         LOGW ("wrong format of transaction\n");
2381                 } else if (cmd == ISM_TRANS_CMD_HIDE_CANDIDATE) {
2382                     m_info_manager->socket_hide_candidate();
2383                 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
2384                     String uuid;
2385
2386                     if (m_recv_trans.get_data(uuid)) {
2387                         m_info_manager->socket_get_candidate_geometry(uuid);
2388                     } else {
2389                         LOGW ("wrong format of transaction\n");
2390                     }
2391                 } else if (cmd == ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE) {
2392                     m_info_manager->reset_keyboard_ise();
2393                 } else if (cmd == ISM_TRANS_CMD_SET_KEYBOARD_ISE_BY_UUID) {
2394                     String uuid;
2395
2396                     if (m_recv_trans.get_data(uuid)) {
2397                         m_info_manager->socket_set_keyboard_ise(uuid);
2398                     } else {
2399                         LOGW ("wrong format of transaction\n");
2400                     }
2401                 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE) {
2402                     String uuid;
2403
2404                     if (m_recv_trans.get_data(uuid)) {
2405                         m_info_manager->socket_get_keyboard_ise(uuid);
2406                     } else {
2407                         LOGW ("wrong format of transaction\n");
2408                     }
2409                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY) {
2410                     uint32 x, y, width, height;
2411
2412                     if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) &&
2413                         m_recv_trans.get_data(width) && m_recv_trans.get_data(height)) {
2414                         m_info_manager->socket_helper_update_ise_geometry(client_id, x, y, width, height);
2415                     } else {
2416                         LOGW ("wrong format of transaction\n");
2417                     }
2418                 } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE) {
2419                     m_info_manager->expand_candidate();
2420                 } else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE) {
2421                     m_info_manager->contract_candidate();
2422                 } else if (cmd == ISM_TRANS_CMD_SELECT_CANDIDATE) {
2423                     uint32 index;
2424
2425                     if (m_recv_trans.get_data(index))
2426                         m_info_manager->socket_helper_select_candidate(index);
2427                     else
2428                         LOGW ("wrong format of transaction\n");
2429                 } else if (cmd == SCIM_TRANS_CMD_GET_SURROUNDING_TEXT) {
2430                     String uuid;
2431                     uint32 maxlen_before;
2432                     uint32 maxlen_after;
2433
2434                     if (m_recv_trans.get_data(uuid) &&
2435                         m_recv_trans.get_data(maxlen_before) &&
2436                         m_recv_trans.get_data(maxlen_after)) {
2437                         m_info_manager->socket_helper_get_surrounding_text(client_id, uuid, maxlen_before, maxlen_after);
2438                     } else {
2439                         LOGW ("wrong format of transaction\n");
2440                     }
2441                 } else if (cmd == SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
2442                     uint32 offset;
2443                     uint32 len;
2444
2445                     if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
2446                         m_info_manager->socket_helper_delete_surrounding_text(client_id, offset, len);
2447                     } else {
2448                         LOGW ("wrong format of transaction\n");
2449                     }
2450                 } else if (cmd == SCIM_TRANS_CMD_GET_SELECTION) {
2451                     String uuid;
2452
2453                     if (m_recv_trans.get_data(uuid)) {
2454                         m_info_manager->socket_helper_get_selection(client_id, uuid);
2455                     } else {
2456                         LOGW ("wrong format of transaction\n");
2457                     }
2458                 } else if (cmd == SCIM_TRANS_CMD_SET_SELECTION) {
2459                     uint32 start;
2460                     uint32 end;
2461
2462                     if (m_recv_trans.get_data(start) && m_recv_trans.get_data(end)) {
2463                         m_info_manager->socket_helper_set_selection(client_id, start, end);
2464                     } else {
2465                         LOGW ("wrong format of transaction\n");
2466                     }
2467                 } else if (cmd == SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND) {
2468                     String command;
2469
2470                     if (m_recv_trans.get_data(command)) {
2471                         m_info_manager->socket_helper_send_private_command(client_id, command);
2472                     } else {
2473                         LOGW ("wrong format of transaction\n");
2474                     }
2475                 //FIXME: useless
2476                 //} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_EXIT) {
2477                 //    m_info_manager->UPDATE_ISE_EXIT(client_id);
2478                 } else {
2479                     LOGW ("unknow cmd: %d\n", cmd);
2480                 }
2481             }
2482
2483             socket_transaction_end();
2484         } else if (client_info.type == IMCONTROL_ACT_CLIENT) {
2485             socket_transaction_start();
2486
2487             while (m_recv_trans.get_command(cmd)) {
2488                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2489
2490                 if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE) {
2491
2492                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2493                         String default_uuid;
2494                         m_info_manager->get_active_ise(client_id, default_uuid);
2495                         Transaction trans;
2496                         Socket client_socket(client_id);
2497
2498                         trans.clear();
2499                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2500                         trans.put_command(SCIM_TRANS_CMD_OK);
2501                         trans.put_data(default_uuid);
2502                         trans.write_to_socket(client_socket);
2503                     }
2504                     else {
2505                         LOGW ("Access denied to get active ise\n");
2506                         send_fail_reply (client_id);
2507                     }
2508                 } else if (cmd == ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID) {
2509                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2510                         char*   buf = NULL;
2511                         size_t  len;
2512                         bool ret = false;
2513
2514                         if (m_recv_trans.get_data(&buf, len)) {
2515                             ret = m_info_manager->set_active_ise_by_uuid(client_id, buf, len);
2516                         } else {
2517                             LOGW ("wrong format of transaction\n");
2518                         }
2519
2520                         Transaction trans;
2521                         Socket client_socket(client_id);
2522
2523                         trans.clear();
2524                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2525                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2526                         trans.write_to_socket(client_socket);
2527
2528                         if (NULL != buf)
2529                             delete[] buf;
2530                     }
2531                     else {
2532                         LOGW ("Access denied to set active ise\n");
2533                         send_fail_reply (client_id);
2534                     }
2535                 } else if (cmd == ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID) {
2536                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2537                         char*   buf = NULL;
2538                         size_t  len;
2539                         bool ret = true;
2540
2541                         //FIXME
2542                         //ret need be checked
2543                         if (m_recv_trans.get_data(&buf, len)) {
2544                             m_info_manager->set_initial_ise_by_uuid(client_id, buf, len);
2545                         } else {
2546                             LOGW ("wrong format of transaction\n");
2547                         }
2548
2549                         Transaction trans;
2550                         Socket client_socket(client_id);
2551
2552                         trans.clear();
2553                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2554                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2555                         trans.write_to_socket(client_socket);
2556
2557                         if (NULL != buf)
2558                             delete[] buf;
2559                     }
2560                     else {
2561                         LOGW ("Access denied to set initial ise\n");
2562                         send_fail_reply (client_id);
2563                     }
2564                 } else if (cmd == ISM_TRANS_CMD_GET_ISE_LIST) {
2565                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2566                         std::vector<String> strlist;
2567                         m_info_manager->get_ise_list(client_id, strlist);
2568                         Transaction trans;
2569                         Socket client_socket(client_id);
2570                         char* buf = NULL;
2571                         size_t len;
2572                         uint32 num;
2573
2574                         trans.clear();
2575                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2576                         trans.put_command(SCIM_TRANS_CMD_OK);
2577
2578                         num = strlist.size();
2579                         trans.put_data(num);
2580
2581                         for (unsigned int i = 0; i < num; i++) {
2582                             buf = const_cast<char*>(strlist[i].c_str());
2583                             len = strlen(buf) + 1;
2584                             trans.put_data(buf, len);
2585                         }
2586
2587                         trans.write_to_socket(client_socket);
2588                     }
2589                     else {
2590                         LOGW ("Access denied to get ise list\n");
2591                         send_fail_reply (client_id);
2592                     }
2593                 } else if (cmd == ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO) {
2594                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2595                         HELPER_ISE_INFO info;
2596                         m_info_manager->get_all_helper_ise_info(client_id, info);
2597
2598                         do {
2599                             Transaction trans;
2600                             Socket client_socket(client_id);
2601
2602                             trans.clear();
2603                             trans.put_command(SCIM_TRANS_CMD_REPLY);
2604                             trans.put_command(SCIM_TRANS_CMD_OK);
2605
2606                             if (info.appid.size() > 0) {
2607                                 trans.put_data(info.appid);
2608                                 trans.put_data(info.label);
2609                                 trans.put_data(info.is_enabled);
2610                                 trans.put_data(info.is_preinstalled);
2611                                 trans.put_data(info.has_option);
2612                             }
2613
2614                             trans.write_to_socket(client_socket);
2615                         } while (0);
2616                     }
2617                     else {
2618                         LOGW ("Access denied to get all helper ise info\n");
2619                         send_fail_reply (client_id);
2620                     }
2621                 } else if (cmd == ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO) {
2622                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2623                         String appid;
2624                         uint32 is_enabled;
2625                         bool ret = false;
2626
2627                         if (m_recv_trans.get_data(appid) && appid.length() != 0 && m_recv_trans.get_data(is_enabled)) {
2628                             m_info_manager->set_enable_helper_ise_info(client_id, appid, is_enabled);
2629                             ret = true;
2630                         } else {
2631                             LOGW ("wrong format of transaction\n");
2632                         }
2633
2634                         Transaction trans;
2635                         Socket client_socket(client_id);
2636
2637                         trans.clear();
2638                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2639                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2640                         trans.write_to_socket(client_socket);
2641                     }
2642                     else {
2643                         LOGW ("Access denied to set enable helper ise info\n");
2644                         send_fail_reply (client_id);
2645                     }
2646                 } else if (cmd == ISM_TRANS_CMD_GET_ISE_INFORMATION) {
2647                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2648                         String strUuid, strName, strLanguage, strModuleName;
2649                         int nType   = 0;
2650                         int nOption = 0;
2651
2652                         if (m_recv_trans.get_data(strUuid)) {
2653                             m_info_manager->get_ise_information(client_id, strUuid, strName, strLanguage, nType, nOption, strModuleName);
2654                         } else {
2655                             LOGW ("wrong format of transaction\n");
2656                         }
2657
2658                         Transaction trans;
2659                         Socket client_socket(client_id);
2660                         trans.clear();
2661                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2662                         trans.put_command(SCIM_TRANS_CMD_OK);
2663                         trans.put_data(strName);
2664                         trans.put_data(strLanguage);
2665                         trans.put_data(nType);
2666                         trans.put_data(nOption);
2667                         trans.put_data(strModuleName);
2668                         trans.write_to_socket(client_socket);
2669                     }
2670                     else {
2671                         LOGW ("Access denied to get ise information\n");
2672                         send_fail_reply (client_id);
2673                     }
2674                 } else if (cmd == ISM_TRANS_CMD_RESET_ISE_OPTION) {
2675                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2676                         Transaction trans;
2677                         Socket client_socket(client_id);
2678
2679                         trans.clear();
2680                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2681                         trans.put_command(SCIM_TRANS_CMD_OK);
2682                         trans.write_to_socket(client_socket);
2683                         m_info_manager->show_helper_ise_selector(client_id);
2684                         m_info_manager->reset_ise_option(client_id);
2685                     }
2686                     else {
2687                         LOGW ("Access denied to reset ise option\n");
2688                         send_fail_reply (client_id);
2689                     }
2690                 } else if (cmd == ISM_TRANS_CMD_RESET_DEFAULT_ISE) {
2691                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2692                         m_info_manager->reset_default_ise(client_id);
2693                     }
2694                     else {
2695                         LOGW ("Access denied to reset default ise\n");
2696                         send_fail_reply (client_id);
2697                     }
2698                 } else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
2699                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2700                         m_info_manager->show_isf_panel(client_id);
2701                     }
2702                     else {
2703                         LOGW ("Access denied to show isf control\n");
2704                         send_fail_reply (client_id);
2705                     }
2706                 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
2707                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2708                         m_info_manager->show_ise_option_window(client_id);
2709                     }
2710                     else {
2711                         LOGW ("Access denied to show ise option window\n");
2712                         send_fail_reply (client_id);
2713                     }
2714                 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST) {
2715                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2716                         Transaction trans;
2717                         Socket client_socket(client_id);
2718
2719                         trans.clear();
2720                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2721                         trans.put_command(SCIM_TRANS_CMD_OK);
2722                         trans.write_to_socket(client_socket);
2723
2724                         m_info_manager->show_helper_ise_list(client_id);
2725                     }
2726                     else {
2727                         LOGW ("Access denied to show helper ise list\n");
2728                         send_fail_reply (client_id);
2729                     }
2730                 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR) {
2731                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2732                         Transaction trans;
2733                         Socket client_socket(client_id);
2734
2735                         trans.clear();
2736                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2737                         trans.put_command(SCIM_TRANS_CMD_OK);
2738                         trans.write_to_socket(client_socket);
2739                         m_info_manager->show_helper_ise_selector(client_id);
2740                     }
2741                     else {
2742                         LOGW ("Access denied to show helper ise selector\n");
2743                         send_fail_reply (client_id);
2744                     }
2745                 } else if (cmd == ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED) {
2746                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2747                         String strAppid;
2748                         uint32 nEnabled = 0;
2749                         bool ret = true;
2750                         //FIXME
2751                         //ret need be checked
2752                         m_info_manager->is_helper_ise_enabled(client_id, strAppid, nEnabled);
2753                         Transaction trans;
2754                         Socket client_socket(client_id);
2755                         trans.clear();
2756                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2757
2758                         if (ret) {
2759                             trans.put_command(SCIM_TRANS_CMD_OK);
2760                             trans.put_data(static_cast<uint32>(nEnabled));
2761                         } else {
2762                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2763                         }
2764
2765                         trans.write_to_socket(client_socket);
2766                     }
2767                     else {
2768                         LOGW ("Access denied to check helper ise enabled\n");
2769                         send_fail_reply (client_id);
2770                     }
2771                 } else if (cmd == ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY) {
2772                     uint32 angle;
2773
2774                     Transaction trans;
2775                     Socket client_socket(client_id);
2776
2777                     trans.clear();
2778                     trans.put_command(SCIM_TRANS_CMD_REPLY);
2779
2780                     if (m_recv_trans.get_data(angle)) {
2781                         struct rectinfo info = {0, 0, 0, 0};
2782                         m_info_manager->get_recent_ise_geometry(client_id, angle, info);
2783
2784                         trans.put_command(SCIM_TRANS_CMD_OK);
2785                         trans.put_data(info.pos_x);
2786                         trans.put_data(info.pos_y);
2787                         trans.put_data(info.width);
2788                         trans.put_data(info.height);
2789                     } else {
2790                         trans.put_command(SCIM_TRANS_CMD_FAIL);
2791                     }
2792
2793                     trans.write_to_socket(client_socket);
2794                 } else {
2795                     LOGW ("unknow cmd: %d\n", cmd);
2796                 }
2797             }
2798
2799             socket_transaction_end();
2800         }
2801     }
2802
2803     void socket_exception_callback(SocketServer*   server,
2804                                    const Socket&   client) {
2805         SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_exception_callback (" << client.get_id() << ")\n";
2806         LOGD ("client id:%d\n", client.get_id());
2807         socket_close_connection(server, client);
2808     }
2809
2810     bool socket_open_connection(SocketServer*   server,
2811                                 const Socket&   client) {
2812         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_open_connection (" << client.get_id() << ")\n";
2813         LOGD ("client id:%d\n", client.get_id());
2814         uint32 key;
2815         String type = scim_socket_accept_connection(key,
2816                       String("Panel"),
2817                       String("FrontEnd,FrontEnd_Active,Helper,Helper_Active,IMControl_Active,IMControl_Passive"),
2818                       client,
2819                       m_socket_timeout);
2820
2821         if (type.length()) {
2822             ClientType _type = ((type == "FrontEnd") ? FRONTEND_CLIENT :
2823                                 ((type == "FrontEnd_Active") ? FRONTEND_ACT_CLIENT :
2824                                  ((type == "IMControl_Active") ? IMCONTROL_ACT_CLIENT :
2825                                   ((type == "Helper_Active") ? HELPER_ACT_CLIENT :
2826                                    ((type == "IMControl_Passive") ? IMCONTROL_CLIENT : HELPER_CLIENT)))));
2827             lock();
2828             m_info_manager->add_client(client.get_id(), key, _type);
2829             unlock();
2830             return true;
2831         }
2832         LOGW ("open_connection failed\n");
2833
2834         SCIM_DEBUG_MAIN(4) << "Close client connection " << client.get_id() << "\n";
2835         server->close_connection(client);
2836         return false;
2837     }
2838
2839     void socket_close_connection(SocketServer*   server,
2840                                  const Socket&   client) {
2841         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_close_connection (" << client.get_id() << ")\n";
2842         LOGD ("client id:%d\n", client.get_id());
2843         int i = 0;
2844         std::vector<Ecore_Fd_Handler *>::iterator IterPos;
2845
2846         for (IterPos = _read_handler_list.begin (); IterPos != _read_handler_list.end (); ++IterPos,++i) {
2847             if (ecore_main_fd_handler_fd_get (_read_handler_list[i]) == client.get_id()) {
2848                 ecore_main_fd_handler_del (_read_handler_list[i]);
2849                 _read_handler_list.erase (IterPos);
2850                 break;
2851             }
2852         }
2853         m_info_manager->del_client(client.get_id());
2854     }
2855
2856     void socket_transaction_start(void) {
2857         //m_signal_transaction_start ();
2858     }
2859
2860     void socket_transaction_end(void) {
2861         //m_signal_transaction_end ();
2862     }
2863
2864     void lock(void) {
2865         //m_signal_lock ();
2866     }
2867     void unlock(void) {
2868         //m_signal_unlock ();
2869     }
2870 };
2871
2872 } /* namespace scim */
2873
2874 /***************************************************/
2875 /*** Beginning of panel agent interface for ISF ***/
2876 /***************************************************/
2877 static scim::PanelAgentPointer instance;
2878
2879 extern "C" {
2880
2881     EXAPI void scim_module_init(void)
2882     {
2883     }
2884
2885     EXAPI void scim_module_exit(void)
2886     {
2887         instance.reset();
2888     }
2889
2890     EXAPI void scim_panel_agent_module_init(const scim::ConfigPointer& config)
2891     {
2892     }
2893
2894     EXAPI scim::PanelAgentPointer scim_panel_agent_module_get_instance()
2895     {
2896         scim::PanelAgentBase* _instance = NULL;
2897         if (instance.null()) {
2898             try {
2899                 _instance = new scim::EcoreSocketPanelAgent();
2900             } catch (...) {
2901                 delete _instance;
2902                 _instance = NULL;
2903             }
2904             if(_instance)
2905                 instance = _instance;
2906         }
2907         return instance;
2908     }
2909 }
2910
2911 /*
2912 vi:ts=4:nowrap:ai:expandtab
2913 */