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(context);
 953             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 954         }
 955
 956         m_send_trans.put_command(SCIM_TRANS_CMD_EXIT);
 957
 958         Socket client_socket(client);
 959         m_send_trans.write_to_socket(client_socket);
 960     }
 961
 962     void socket_update_surrounding_text(int client, uint32 context, const String& uuid, String& text, uint32 cursor) {
 963         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 964         LOGD ("client id:%d\n", client);
 965
 966         Socket client_socket(client);
 967
 968         m_send_trans.clear();
 969         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 970         m_send_trans.put_data(context);
 971         m_send_trans.put_data(uuid);
 972         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT);
 973         m_send_trans.put_data(text);
 974         m_send_trans.put_data(cursor);
 975         m_send_trans.write_to_socket(client_socket);
 976     }
 977
 978     void socket_update_selection(int client, uint32 context, const String& uuid, String text) {
 979         LOGD ("client id:%d\n", client);
 980
 981         Socket client_socket(client);
 982
 983         m_send_trans.clear();
 984         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 985         m_send_trans.put_data(context);
 986         m_send_trans.put_data(uuid);
 987         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SELECTION);
 988         m_send_trans.put_data(text);
 989         m_send_trans.write_to_socket(client_socket);
 990     }
 991
 992     void socket_get_keyboard_ise_list(int client, uint32 context, const String& uuid, std::vector<String>& list) {
 993         LOGD ("client id:%d\n", client);
 994
 995         Socket socket_client(client);
 996         m_send_trans.clear();
 997         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 998         m_send_trans.put_data(context);
 999         m_send_trans.put_data(uuid);
1000         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE_LIST);
1001         m_send_trans.put_data(list.size());
1002
1003         for (unsigned int i = 0; i < list.size(); i++)
1004             m_send_trans.put_data(list[i]);
1005
1006         m_send_trans.write_to_socket(socket_client);
1007     }
1008
1009     void socket_get_candidate_ui(int client, uint32 context, const String& uuid,  int style,  int mode) {
1010         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_get_candidate_ui ()\n";
1011
1012         LOGD ("client id:%d\n", client);
1013
1014         Socket socket_client(client);
1015         m_send_trans.clear();
1016         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1017         m_send_trans.put_data(context);
1018         m_send_trans.put_data(uuid);
1019         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_UI);
1020         m_send_trans.put_data(style);
1021         m_send_trans.put_data(mode);
1022         m_send_trans.write_to_socket(socket_client);
1023     }
1024
1025     void socket_get_candidate_geometry(int client, uint32 context, const String& uuid, struct rectinfo& info) {
1026         SCIM_DEBUG_MAIN(4) << __func__ << " \n";
1027
1028         LOGD ("client id:%d\n", client);
1029
1030         Socket socket_client(client);
1031         m_send_trans.clear();
1032         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1033         m_send_trans.put_data(context);
1034         m_send_trans.put_data(uuid);
1035         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_GEOMETRY);
1036         m_send_trans.put_data(info.pos_x);
1037         m_send_trans.put_data(info.pos_y);
1038         m_send_trans.put_data(info.width);
1039         m_send_trans.put_data(info.height);
1040         m_send_trans.write_to_socket(socket_client);
1041     }
1042
1043     void socket_get_keyboard_ise(int client, uint32 context, const String& uuid, String& ise_name, String& ise_uuid) {
1044         LOGD ("client id:%d\n", client);
1045
1046         Socket socket_client(client);
1047         m_send_trans.clear();
1048         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1049         m_send_trans.put_data(context);
1050         m_send_trans.put_data(uuid);
1051         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE);
1052         m_send_trans.put_data(ise_name);
1053         m_send_trans.put_data(ise_uuid);
1054         m_send_trans.write_to_socket(socket_client);
1055     }
1056
1057     void socket_start_helper(int client, uint32 context, const String& ic_uuid) {
1058         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_start_helper ()\n";
1059
1060         LOGD ("client id:%d\n", client);
1061
1062         Socket client_socket(client);
1063         m_send_trans.clear();
1064         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1065         m_send_trans.put_data(context);
1066         m_send_trans.put_data(ic_uuid);
1067         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1068         m_send_trans.write_to_socket(client_socket);
1069     }
1070
1071     void helper_detach_input_context(int client, uint32 context, const String& ic_uuid) {
1072         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_stop_helper ()\n";
1073
1074         LOGD ("client id:%d\n", client);
1075
1076         Socket client_socket(client);
1077         m_send_trans.clear();
1078         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1079         m_send_trans.put_data(context);
1080         m_send_trans.put_data(ic_uuid);
1081         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_DETACH_INPUT_CONTEXT);
1082         m_send_trans.write_to_socket(client_socket);
1083     }
1084
1085     void helper_process_imengine_event(int client, uint32 context, const String& ic_uuid, const Transaction& _nest_trans) {
1086         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_send_helper_event ()\n";
1087         LOGD ("client id:%d\n", client);
1088
1089         Socket client_socket(client);
1090
1091         lock();
1092
1093         m_send_trans.clear();
1094         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1095
1096         /* FIXME: We presume that client and context are both less than 65536.
1097          * Hopefully, it should be true in any UNIXs.
1098          * So it's ok to combine client and context into one uint32. */
1099         m_send_trans.put_data(context);
1100         m_send_trans.put_data(ic_uuid);
1101         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_PROCESS_IMENGINE_EVENT);
1102         m_send_trans.put_data(_nest_trans);
1103         m_send_trans.write_to_socket(client_socket);
1104
1105         unlock();
1106     }
1107
1108     void process_helper_event(int client, uint32 context, String target_uuid, String active_uuid, Transaction& nest_trans) {
1109         LOGD ("client id:%d\n", client);
1110
1111         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_helper_send_imengine_event (" << client << ")\n";
1112         Socket socket_client(client);
1113         lock();
1114         m_send_trans.clear();
1115         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1116         m_send_trans.put_data(context);
1117         m_send_trans.put_command(SCIM_TRANS_CMD_PROCESS_HELPER_EVENT);
1118         m_send_trans.put_data(target_uuid);
1119         m_send_trans.put_data(active_uuid);
1120         m_send_trans.put_data(nest_trans);
1121         m_send_trans.write_to_socket(socket_client);
1122         unlock();
1123
1124     }
1125
1126     void socket_helper_key_event(int client, uint32 context, int cmd, KeyEvent& key) {
1127         LOGD ("client id:%d\n", client);
1128
1129         Socket socket_client(client);
1130         lock();
1131         m_send_trans.clear();
1132         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1133         m_send_trans.put_data(context);
1134         m_send_trans.put_command(cmd);
1135         m_send_trans.put_data(key);
1136         m_send_trans.write_to_socket(socket_client);
1137         unlock();
1138     }
1139
1140     void commit_string(int client, uint32 target_context, const WideString& wstr) {
1141         LOGD ("client id:%d\n", client);
1142
1143         Socket socket_client(client);
1144         lock();
1145         m_send_trans.clear();
1146         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1147         m_send_trans.put_data(target_context);
1148         m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_STRING);
1149         m_send_trans.put_data(wstr);
1150         m_send_trans.write_to_socket(socket_client);
1151         unlock();
1152     }
1153
1154     void socket_helper_get_surrounding_text(int client, uint32 context_id, uint32 maxlen_before, uint32 maxlen_after) {
1155         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1156         LOGD ("client id:%d\n", client);
1157
1158         Socket socket_client(client);
1159         lock();
1160         m_send_trans.clear();
1161         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1162         m_send_trans.put_data(context_id);
1163         m_send_trans.put_command(SCIM_TRANS_CMD_GET_SURROUNDING_TEXT);
1164         m_send_trans.put_data(maxlen_before);
1165         m_send_trans.put_data(maxlen_after);
1166         m_send_trans.write_to_socket(socket_client);
1167         unlock();
1168     }
1169
1170     void socket_helper_delete_surrounding_text(int client, uint32 context_id, uint32 offset, uint32 len) {
1171         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1172         LOGD ("client id:%d\n", client);
1173
1174         Socket socket_client(client);
1175         lock();
1176         m_send_trans.clear();
1177         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1178         m_send_trans.put_data(context_id);
1179         m_send_trans.put_command(SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT);
1180         m_send_trans.put_data(offset);
1181         m_send_trans.put_data(len);
1182         m_send_trans.write_to_socket(socket_client);
1183         unlock();
1184     }
1185
1186     void socket_helper_get_selection(int client, uint32 context_id) {
1187         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1188         LOGD ("client id:%d\n", client);
1189
1190
1191         Socket socket_client(client);
1192         lock();
1193         m_send_trans.clear();
1194         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1195         m_send_trans.put_data(context_id);
1196         m_send_trans.put_command(SCIM_TRANS_CMD_GET_SELECTION);
1197         m_send_trans.write_to_socket(socket_client);
1198         unlock();
1199     }
1200
1201     void socket_helper_set_selection(int client, uint32 context_id, uint32 start, uint32 end) {
1202         LOGD ("client id:%d\n", client);
1203
1204         Socket socket_client(client);
1205         lock();
1206         m_send_trans.clear();
1207         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1208         m_send_trans.put_data(context_id);
1209         m_send_trans.put_command(SCIM_TRANS_CMD_SET_SELECTION);
1210         m_send_trans.put_data(start);
1211         m_send_trans.put_data(end);
1212         m_send_trans.write_to_socket(socket_client);
1213         unlock();
1214     }
1215
1216     void show_preedit_string(int client, uint32  target_context) {
1217         LOGD ("client id:%d\n", client);
1218
1219         Socket socket_client(client);
1220         lock();
1221         m_send_trans.clear();
1222         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1223         m_send_trans.put_data(target_context);
1224         m_send_trans.put_command(SCIM_TRANS_CMD_SHOW_PREEDIT_STRING);
1225         m_send_trans.write_to_socket(socket_client);
1226         unlock();
1227     }
1228
1229     void hide_preedit_string(int client, uint32  target_context) {
1230         LOGD ("client id:%d\n", client);
1231
1232         Socket socket_client(client);
1233         lock();
1234         m_send_trans.clear();
1235         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1236         m_send_trans.put_data(target_context);
1237         m_send_trans.put_command(SCIM_TRANS_CMD_HIDE_PREEDIT_STRING);
1238         m_send_trans.write_to_socket(socket_client);
1239         unlock();
1240     }
1241
1242     void update_preedit_string(int client, uint32  target_context, WideString wstr, AttributeList& attrs, uint32 caret) {
1243         LOGD ("client id:%d\n", client);
1244
1245         Socket socket_client(client);
1246         lock();
1247         m_send_trans.clear();
1248         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1249         m_send_trans.put_data(target_context);
1250         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
1251         m_send_trans.put_data(wstr);
1252         m_send_trans.put_data(attrs);
1253         m_send_trans.put_data(caret);
1254         m_send_trans.write_to_socket(socket_client);
1255         unlock();
1256
1257     }
1258
1259     void update_preedit_caret(int client, uint32 focused_context, uint32 caret) {
1260
1261         LOGD ("client id:%d\n", client);
1262
1263         Socket socket_client(client);
1264         lock();
1265         m_send_trans.clear();
1266         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1267         m_send_trans.put_data(focused_context);
1268         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET);
1269         m_send_trans.put_data(caret);
1270         m_send_trans.write_to_socket(socket_client);
1271         unlock();
1272
1273     }
1274
1275     void helper_attach_input_context_and_update_screen(int client, std::vector < std::pair <uint32, String> >& helper_ic_index, uint32 current_screen) {
1276         LOGD ("client id:%d\n", client);
1277
1278         Socket socket_client(client);
1279         m_send_trans.clear();
1280         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1281         m_send_trans.put_command(SCIM_TRANS_CMD_OK);
1282         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1283
1284         for (size_t i = 0; i < helper_ic_index.size(); ++i) {
1285             m_send_trans.put_data(helper_ic_index[i].first);
1286             m_send_trans.put_data(helper_ic_index[i].second);
1287         }
1288
1289         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1290         m_send_trans.put_data((uint32)current_screen);
1291         m_send_trans.write_to_socket(socket_client);
1292     }
1293
1294     void update_ise_input_context(int client, uint32 focused_context, uint32 type, uint32 value) {
1295         LOGD ("client id:%d\n", client);
1296
1297         Socket client_socket(client);
1298         m_send_trans.clear();
1299         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1300         m_send_trans.put_data(focused_context);
1301         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT);
1302         m_send_trans.put_data(type);
1303         m_send_trans.put_data(value);
1304         m_send_trans.write_to_socket(client_socket);
1305
1306     }
1307
1308     void send_private_command(int client, uint32 focused_context, String command) {
1309         LOGD ("client id:%d\n", client);
1310
1311         Socket socket_client(client);
1312         lock();
1313         m_send_trans.clear();
1314         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1315         m_send_trans.put_data(focused_context);
1316         m_send_trans.put_command(SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND);
1317         m_send_trans.put_data(command);
1318         m_send_trans.write_to_socket(socket_client);
1319
1320     }
1321
1322
1323     void helper_all_update_spot_location(int client, uint32 context_id, String uuid, int x, int y) {
1324         LOGD ("client id:%d\n", client);
1325
1326         m_send_trans.clear();
1327         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1328
1329         /* FIXME: We presume that client and context are both less than 65536.
1330          * Hopefully, it should be true in any UNIXs.
1331          * So it's ok to combine client and context into one uint32. */
1332         m_send_trans.put_data(context_id);
1333         m_send_trans.put_data(uuid);
1334         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION);
1335         m_send_trans.put_data((uint32) x);
1336         m_send_trans.put_data((uint32) y);
1337
1338         Socket client_socket(client);
1339         m_send_trans.write_to_socket(client_socket);
1340
1341     }
1342
1343     void helper_all_update_cursor_position(int client, uint32 context_id, String uuid, int cursor_pos) {
1344         LOGD ("client id:%d\n", client);
1345
1346         m_send_trans.clear();
1347         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1348         m_send_trans.put_data(context_id);
1349         m_send_trans.put_data(uuid);
1350         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CURSOR_POSITION);
1351         m_send_trans.put_data((uint32) cursor_pos);
1352
1353         Socket client_socket(client);
1354         m_send_trans.write_to_socket(client_socket);
1355
1356     }
1357
1358     void helper_all_update_screen(int client, uint32 context_id, String uuid, int screen) {
1359         LOGD ("client id:%d\n", client);
1360
1361         m_send_trans.clear();
1362         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1363
1364         /* FIXME: We presume that client and context are both less than 65536.
1365          * Hopefully, it should be true in any UNIXs.
1366          * So it's ok to combine client and context into one uint32. */
1367         m_send_trans.put_data(context_id);
1368         m_send_trans.put_data(uuid);
1369         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1370         m_send_trans.put_data((uint32) screen);
1371
1372         Socket client_socket(client);
1373         m_send_trans.write_to_socket(client_socket);
1374
1375     }
1376
1377 private:
1378
1379     static void send_fail_reply (int client_id)
1380     {
1381         Socket client_socket (client_id);
1382         Transaction trans;
1383         trans.clear ();
1384         trans.put_command (SCIM_TRANS_CMD_REPLY);
1385         trans.put_command (SCIM_TRANS_CMD_FAIL);
1386         trans.write_to_socket (client_socket);
1387     }
1388
1389     bool filter_event(int fd) {
1390         SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_event ()\n";
1391
1392         return m_socket_server.filter_event(fd);
1393     }
1394
1395     bool filter_exception_event(int fd) {
1396         SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_exception_event ()\n";
1397
1398         return m_socket_server.filter_exception_event(fd);
1399     }
1400
1401     int get_server_id() {
1402         SCIM_DEBUG_MAIN(1) << "PanelAgent::get_server_id ()\n";
1403
1404         return m_socket_server.get_id();
1405     }
1406
1407     bool socket_check_client_connection(const Socket& client) {
1408         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_check_client_connection (" << client.get_id() << ")\n";
1409
1410         unsigned char buf [sizeof(uint32)];
1411
1412         int nbytes = client.read_with_timeout(buf, sizeof(uint32), m_socket_timeout);
1413
1414         if (nbytes == sizeof(uint32))
1415             return true;
1416
1417         if (nbytes < 0) {
1418             LOGW ("Error occurred when reading socket: %s\n", client.get_error_message().c_str());
1419         } else {
1420             LOGW ("Timeout when reading socket\n");
1421         }
1422
1423         return false;
1424     }
1425
1426     /**
1427      * @brief Callback function for ecore fd handler.
1428      *
1429      * @param data The data to pass to this callback.
1430      * @param fd_handler The ecore fd handler.
1431      *
1432      * @return ECORE_CALLBACK_RENEW
1433      */
1434     static Eina_Bool panel_agent_handler(void* data, Ecore_Fd_Handler* fd_handler) {
1435         if (fd_handler == NULL || data == NULL)
1436             return ECORE_CALLBACK_RENEW;
1437
1438         EcoreSocketPanelAgent* _agent = (EcoreSocketPanelAgent*)data;
1439
1440         int fd = ecore_main_fd_handler_fd_get(fd_handler);
1441
1442         for (unsigned int i = 0; i < _agent->_read_handler_list.size(); i++) {
1443             if (fd_handler == _agent->_read_handler_list [i]) {
1444                 if (!_agent->filter_event(fd)) {
1445                     std::cerr << "_panel_agent->filter_event () is failed!!!\n";
1446                     ecore_main_fd_handler_del(fd_handler);
1447
1448                     ISF_SAVE_LOG("_panel_agent->filter_event (fd=%d) is failed!!!\n", fd);
1449                 }
1450
1451                 return ECORE_CALLBACK_RENEW;
1452             }
1453         }
1454
1455         std::cerr << "panel_agent_handler () has received exception event!!!\n";
1456         _agent->filter_exception_event(fd);
1457         ecore_main_fd_handler_del(fd_handler);
1458
1459         ISF_SAVE_LOG("Received exception event (fd=%d)!!!\n", fd);
1460         return ECORE_CALLBACK_RENEW;
1461     }
1462
1463     void socket_accept_callback(SocketServer*   server,
1464                                 const Socket&   client) {
1465         SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_accept_callback (" << client.get_id() << ")\n";
1466         LOGD ("");
1467         lock();
1468
1469         if (m_should_exit) {
1470             SCIM_DEBUG_MAIN(3) << "Exit Socket Server Thread.\n";
1471             server->shutdown();
1472         } else {
1473             //m_signal_accept_connection (client.get_id ());
1474             Ecore_Fd_Handler* panel_agent_read_handler = ecore_main_fd_handler_add(client.get_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
1475             _read_handler_list.push_back(panel_agent_read_handler);
1476         }
1477
1478         unlock();
1479     }
1480
1481     void socket_receive_callback(SocketServer*   server,
1482                                  const Socket&   client) {
1483         int     client_id = client.get_id();
1484         int     cmd     = 0;
1485         uint32  key     = 0;
1486         uint32  context = 0;
1487         String  uuid;
1488
1489         ClientInfo client_info;
1490
1491         SCIM_DEBUG_MAIN(1) << "PanelAgent::socket_receive_callback (" << client_id << ")\n";
1492
1493         /* If the connection is closed then close this client. */
1494         if (!socket_check_client_connection(client)) {
1495             LOGW ("check client connection failed\n");
1496             socket_close_connection(server, client);
1497             return;
1498         }
1499
1500         client_info = m_info_manager->socket_get_client_info(client_id);
1501
1502         /* If it's a new client, then request to open the connection first. */
1503         if (client_info.type == UNKNOWN_CLIENT) {
1504             socket_open_connection(server, client);
1505             return;
1506         }
1507
1508         /* If can not read the transaction,
1509          * or the transaction is not started with SCIM_TRANS_CMD_REQUEST,
1510          * or the key is mismatch,
1511          * just return. */
1512         if (!m_recv_trans.read_from_socket(client, m_socket_timeout) ||
1513             !m_recv_trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REQUEST ||
1514             !m_recv_trans.get_data(key)    || key != (uint32) client_info.key) {
1515             LOGW ("cmd:%d key:%d client info key: %d\n", cmd, key, client_info.key);
1516             return;
1517         }
1518
1519         if (client_info.type == FRONTEND_ACT_CLIENT) {
1520             if (m_recv_trans.get_data(context)) {
1521                 SCIM_DEBUG_MAIN(1) << "PanelAgent::FrontEnd Client, context = " << context << "\n";
1522                 socket_transaction_start();
1523
1524                 while (m_recv_trans.get_command(cmd)) {
1525                     LOGD ("PanelAgent::cmd = %d\n", cmd);
1526
1527                     if (cmd == ISM_TRANS_CMD_REGISTER_PANEL_CLIENT) {
1528                         uint32 id = 0;
1529
1530                         if (m_recv_trans.get_data(id)) {
1531                             m_info_manager->register_panel_client(client_id, id);
1532                         } else {
1533                             LOGW ("wrong format of transaction\n");
1534                         }
1535
1536                         continue;
1537                     }
1538
1539                     else if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_INPUT_CONTEXT) {
1540                         if (m_recv_trans.get_data(uuid)) {
1541                             m_info_manager->register_input_context(client_id, context, uuid);
1542                         } else {
1543                             LOGW ("wrong format of transaction\n");
1544                         }
1545
1546                         continue;
1547                     }
1548
1549                     else if (cmd == SCIM_TRANS_CMD_PANEL_REMOVE_INPUT_CONTEXT) {
1550                         m_info_manager->remove_input_context(client_id, context);
1551                         continue;
1552                     }
1553
1554                     else if (cmd == SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT) {
1555                         m_info_manager->socket_reset_input_context(client_id, context);
1556                         continue;
1557                     }
1558
1559                     else if (cmd == SCIM_TRANS_CMD_FOCUS_IN) {
1560                         SCIM_DEBUG_MAIN(4) << "    SCIM_TRANS_CMD_FOCUS_IN (" << "client:" << client_id << " context:" << context << ")\n";
1561
1562                         if (m_recv_trans.get_data(uuid)) {
1563                             m_info_manager->focus_in(client_id, context, uuid);
1564                         } else {
1565                             LOGW ("wrong format of transaction\n");
1566                         }
1567
1568                         continue;
1569                     }
1570
1571                     else if (cmd == ISM_TRANS_CMD_TURN_ON_LOG) {
1572                         uint32 isOn;
1573
1574                         if (m_recv_trans.get_data(isOn)) {
1575                             m_info_manager->socket_turn_on_log(isOn);
1576                         } else {
1577                             LOGW ("wrong format of transaction\n");
1578                         }
1579
1580                         continue;
1581                     }
1582
1583                     else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
1584                         m_info_manager->show_isf_panel(client_id);
1585                         continue;
1586                     } else if (cmd == ISM_TRANS_CMD_HIDE_ISF_CONTROL) {
1587                         m_info_manager->hide_isf_panel(client_id);
1588                         continue;
1589                     } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_PANEL) {
1590                         uint32 client;
1591                         uint32 context;
1592                         char*   data = NULL;
1593                         size_t  len;
1594                         bool ret = false;
1595
1596                         if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context) && m_recv_trans.get_data(&data, len)) {
1597                             ret = true;
1598                         } else {
1599                             LOGW ("wrong format of transaction\n");
1600                         }
1601
1602                         Transaction trans;
1603                         Socket client_socket(client_id);
1604
1605                         trans.clear();
1606                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1607                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
1608                         trans.put_data(ret);
1609                         trans.write_to_socket(client_socket);
1610
1611                         if (data != NULL)
1612                             delete[] data;
1613
1614                         if (ret)
1615                             m_info_manager->show_ise_panel(client_id, client, context, data, len);
1616
1617                         continue;
1618                     } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
1619                         uint32 client;
1620                         uint32 context;
1621
1622                         if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context)) {
1623                             m_info_manager->hide_ise_panel(client_id, client, context);
1624                         } else {
1625                             LOGW ("wrong format of transaction\n");
1626                         }
1627
1628                         continue;
1629                     } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY) {
1630                         struct rectinfo info;
1631                         m_info_manager->get_input_panel_geometry(client_id, info);
1632                         Transaction trans;
1633                         Socket client_socket(client_id);
1634
1635                         trans.clear();
1636                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1637                         trans.put_command(SCIM_TRANS_CMD_OK);
1638                         trans.put_data(info.pos_x);
1639                         trans.put_data(info.pos_y);
1640                         trans.put_data(info.width);
1641                         trans.put_data(info.height);
1642                         trans.write_to_socket(client_socket);
1643                         continue;
1644                     } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
1645                         struct rectinfo info;
1646                         m_info_manager->get_candidate_window_geometry(client_id, info);
1647                         Transaction trans;
1648                         Socket client_socket(client_id);
1649
1650                         trans.clear();
1651                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1652                         trans.put_command(SCIM_TRANS_CMD_OK);
1653                         trans.put_data(info.pos_x);
1654                         trans.put_data(info.pos_y);
1655                         trans.put_data(info.width);
1656                         trans.put_data(info.height);
1657                         trans.write_to_socket(client_socket);
1658                         continue;
1659                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE) {
1660                         size_t  len;
1661                         char*   data = NULL;
1662                         m_info_manager->get_ise_language_locale(client_id, data, len);
1663                         Transaction trans;
1664                         trans.clear();
1665                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1666
1667                         if (data != NULL && len > 0) {
1668                             trans.put_command(SCIM_TRANS_CMD_OK);
1669                             trans.put_data(data, len);
1670                         } else {
1671                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1672                         }
1673
1674                         Socket client_socket(client_id);
1675                         trans.write_to_socket(client_socket);
1676
1677                         if (NULL != data)
1678                             delete [] data;
1679
1680                         continue;
1681                     } else if (cmd == ISM_TRANS_CMD_SET_ISE_LANGUAGE) {
1682                         uint32 language;
1683
1684                         if (m_recv_trans.get_data(language)) {
1685                             m_info_manager->set_ise_language(client_id, language);
1686                         } else {
1687                             LOGW ("wrong format of transaction\n");
1688                         }
1689
1690                         continue;
1691                     } else if (cmd == ISM_TRANS_CMD_SET_ISE_IMDATA) {
1692                         char*   imdata = NULL;
1693                         size_t  len;
1694
1695                         if (m_recv_trans.get_data(&imdata, len)) {
1696                             m_info_manager->set_ise_imdata(client_id, imdata, len);
1697                         } else {
1698                             LOGW ("wrong format of transaction\n");
1699                         }
1700
1701                         if (NULL != imdata)
1702                             delete [] imdata;
1703
1704                         continue;
1705                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_IMDATA) {
1706                         char*   imdata = NULL;
1707                         size_t  len = 0;
1708                         m_info_manager->get_ise_imdata(client_id, &imdata, len);
1709                         Transaction trans;
1710                         Socket client_socket(client_id);
1711
1712                         trans.clear();
1713                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1714
1715                         if (len) {
1716                             trans.put_command(SCIM_TRANS_CMD_OK);
1717                             trans.put_data(imdata, len);
1718                         } else {
1719                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1720                         }
1721
1722                         trans.write_to_socket(client_socket);
1723
1724                         if (NULL != imdata)
1725                             delete [] imdata;
1726
1727                         continue;
1728                     } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_TYPE) {
1729                         uint32 type;
1730
1731                         if (m_recv_trans.get_data(type)) {
1732                             m_info_manager->set_ise_return_key_type(client_id, type);
1733                         } else {
1734                             LOGW ("wrong format of transaction\n");
1735                         }
1736
1737                         continue;
1738                     } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_TYPE) {
1739                         uint32 type;
1740                         bool ret = m_info_manager->get_ise_return_key_type(client_id, type);
1741                         Transaction trans;
1742                         Socket client_socket(client_id);
1743
1744                         trans.clear();
1745                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1746
1747                         if (ret) {
1748                             trans.put_command(SCIM_TRANS_CMD_OK);
1749                             trans.put_data(type);
1750                         } else {
1751                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1752                         }
1753
1754                         trans.write_to_socket(client_socket);
1755                         continue;
1756                     } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE) {
1757                         uint32 disabled;
1758
1759                         if (m_recv_trans.get_data(disabled)) {
1760                             m_info_manager->set_ise_return_key_disable(client_id, disabled);
1761                         } else {
1762                             LOGW ("wrong format of transaction\n");
1763                         }
1764
1765                         continue;
1766                     } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE) {
1767                         uint32 disabled;
1768                         bool ret = true;
1769                         m_info_manager->get_ise_return_key_disable(client_id, disabled);
1770                         Transaction trans;
1771                         Socket client_socket(client_id);
1772
1773                         trans.clear();
1774                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1775
1776                         if (ret) {
1777                             trans.put_command(SCIM_TRANS_CMD_OK);
1778                             trans.put_data(disabled);
1779                         } else {
1780                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1781                         }
1782
1783                         trans.write_to_socket(client_socket);
1784                         continue;
1785                     } else if (cmd == ISM_TRANS_CMD_GET_LAYOUT) {
1786                         uint32 layout;
1787                         bool ret = m_info_manager->get_ise_layout(client_id, layout);
1788                         Transaction trans;
1789                         Socket client_socket(client_id);
1790
1791                         trans.clear();
1792                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1793
1794                         if (ret) {
1795                             trans.put_command(SCIM_TRANS_CMD_OK);
1796                             trans.put_data(layout);
1797                         } else {
1798                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1799                         }
1800
1801                         trans.write_to_socket(client_socket);
1802                         continue;
1803                     } else if (cmd == ISM_TRANS_CMD_SET_LAYOUT) {
1804                         uint32 layout;
1805
1806                         if (m_recv_trans.get_data(layout)) {
1807                             m_info_manager->set_ise_layout(client_id, layout);
1808                         } else {
1809                             LOGW ("wrong format of transaction\n");
1810                         }
1811
1812                         continue;
1813                     } else if (cmd == ISM_TRANS_CMD_SET_CAPS_MODE) {
1814                         uint32 mode;
1815
1816                         if (m_recv_trans.get_data(mode)) {
1817                             m_info_manager->set_ise_caps_mode(client_id, mode);
1818                         } else {
1819                             LOGW ("wrong format of transaction\n");
1820                         }
1821
1822                         continue;
1823                     } else if (cmd == ISM_TRANS_CMD_SEND_WILL_SHOW_ACK) {
1824                         m_info_manager->will_show_ack(client_id);
1825                         continue;
1826                     } else if (cmd == ISM_TRANS_CMD_SEND_WILL_HIDE_ACK) {
1827                         m_info_manager->will_hide_ack(client_id);
1828                         continue;
1829                     } else if (cmd == ISM_TRANS_CMD_SET_HARDWARE_KEYBOARD_MODE) {
1830                         uint32 mode;
1831
1832                         if (m_recv_trans.get_data(mode)) {
1833                             m_info_manager->set_keyboard_mode(client_id, mode);
1834                         } else {
1835                             LOGW ("wrong format of transaction\n");
1836                         }
1837
1838                         continue;
1839                     } else if (cmd == ISM_TRANS_CMD_SEND_CANDIDATE_WILL_HIDE_ACK) {
1840                         m_info_manager->candidate_will_hide_ack(client_id);
1841                         continue;
1842                     } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT) {
1843                         uint32 result = 0;
1844                         bool   ret      = false;
1845
1846                         KeyEvent key;
1847
1848                         if (m_recv_trans.get_data(key)) {
1849                             ret      = true;
1850                             m_info_manager->process_key_event(key, result);
1851                         } else {
1852                             LOGW ("wrong format of transaction\n");
1853                         }
1854
1855                         Transaction trans;
1856                         Socket client_socket(client_id);
1857
1858                         trans.clear();
1859                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1860
1861                         if (ret) {
1862                             trans.put_command(SCIM_TRANS_CMD_OK);
1863                             trans.put_data(result);
1864                         } else {
1865                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1866                         }
1867
1868                         trans.write_to_socket(client_socket);
1869                         continue;
1870                     } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_HELPER_OPTION) {
1871                         uint32 option;
1872                         m_info_manager->get_active_helper_option(client_id, option);
1873                         Transaction trans;
1874                         Socket client_socket(client_id);
1875
1876                         trans.clear();
1877                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1878                         trans.put_command(SCIM_TRANS_CMD_OK);
1879                         trans.put_data(option);
1880                         SCIM_DEBUG_MAIN(4) << __func__ << " option " << option << "\n";
1881                         trans.write_to_socket(client_socket);
1882                         continue;
1883                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_STATE) {
1884                         int state = 0;
1885                         m_info_manager->get_ise_state(client_id, state);
1886                         Transaction trans;
1887                         Socket client_socket(client_id);
1888
1889                         trans.clear();
1890                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1891                         trans.put_command(SCIM_TRANS_CMD_OK);
1892                         trans.put_data(state);
1893                         trans.write_to_socket(client_socket);
1894                         continue;
1895                     } else if (cmd == ISM_TRANS_CMD_SET_INPUT_MODE) {
1896                         uint32 input_mode;
1897
1898                         if (m_recv_trans.get_data(input_mode)) {
1899                             m_info_manager->set_ise_input_mode(client_id, input_mode);
1900                         } else {
1901                             LOGW ("wrong format of transaction\n");
1902                         }
1903
1904                         continue;
1905                     } else if (cmd == ISM_TRANS_CMD_SET_INPUT_HINT) {
1906                         uint32 input_hint;
1907
1908                         if (m_recv_trans.get_data(input_hint)) {
1909                             m_info_manager->set_ise_input_hint(client_id, input_hint);
1910                         } else {
1911                             LOGW ("wrong format of transaction\n");
1912                         }
1913
1914                         continue;
1915                     } else if (cmd == ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION) {
1916                         uint32 bidi_direction;
1917
1918                         if (m_recv_trans.get_data(bidi_direction)) {
1919                             m_info_manager->update_ise_bidi_direction(client_id, bidi_direction);
1920                         } else {
1921                             LOGW ("wrong format of transaction\n");
1922                         }
1923
1924                         continue;
1925                     } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
1926                         m_info_manager->show_ise_option_window(client_id);
1927                         continue;
1928                     }
1929
1930                     //FIXME
1931                     //skip data
1932
1933                     else if (cmd == SCIM_TRANS_CMD_START_HELPER) {
1934                         String uuid;
1935
1936                         if (m_recv_trans.get_data(uuid) && uuid.length()) {
1937                             m_info_manager->socket_start_helper(client_id, context, uuid);
1938                         } else {
1939                             LOGW ("wrong format of transaction\n");
1940                         }
1941
1942                         continue;
1943                     } else if (cmd == SCIM_TRANS_CMD_SEND_HELPER_EVENT) {
1944                         String uuid;
1945
1946                         if (m_recv_trans.get_data(uuid) && m_recv_trans.get_data(m_nest_trans) &&
1947                             uuid.length() && m_nest_trans.valid()) {
1948                             m_info_manager->socket_send_helper_event(client_id, context, uuid, m_nest_trans);
1949                         } else {
1950                             LOGW ("wrong format of transaction\n");
1951                         }
1952
1953                         continue;
1954                     } else if (cmd == SCIM_TRANS_CMD_STOP_HELPER) {
1955                         String uuid;
1956
1957                         if (m_recv_trans.get_data(uuid) && uuid.length()) {
1958                             m_info_manager->socket_stop_helper(client_id, context, uuid);
1959                         } else {
1960                             LOGW ("wrong format of transaction\n");
1961                         }
1962
1963                         continue;
1964                     }
1965
1966                     //FIXME
1967                     //skip data
1968
1969                     /* Client must focus in before do any other things. */
1970                     else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_ON)
1971                         m_info_manager->socket_turn_on();
1972                     else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_OFF)
1973                         m_info_manager->socket_turn_off();
1974                     else if (cmd == SCIM_TRANS_CMD_UPDATE_SCREEN) {
1975                         uint32 num;
1976
1977                         if (m_recv_trans.get_data(num))
1978                             m_info_manager->socket_update_screen(client_id, num);
1979                         else
1980                             LOGW ("wrong format of transaction\n");
1981                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION) {
1982                         uint32 x, y, top_y;
1983
1984                         if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) && m_recv_trans.get_data(top_y)) {
1985                             m_info_manager->socket_update_spot_location(x, y, top_y);
1986                         } else {
1987                             LOGW ("wrong format of transaction\n");
1988                         }
1989                     } else if (cmd == ISM_TRANS_CMD_UPDATE_CURSOR_POSITION) {
1990                         uint32 cursor_pos;
1991
1992                         if (m_recv_trans.get_data(cursor_pos)) {
1993                             m_info_manager->socket_update_cursor_position(cursor_pos);
1994                         } else {
1995                             LOGW ("wrong format of transaction\n");
1996                         }
1997                     } else if (cmd == ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT) {
1998                         String text;
1999                         uint32 cursor;
2000
2001                         if (m_recv_trans.get_data(text) && m_recv_trans.get_data(cursor)) {
2002                             m_info_manager->socket_update_surrounding_text(text, cursor);
2003                         } else {
2004                             LOGW ("wrong format of transaction\n");
2005                         }
2006                     } else if (cmd == ISM_TRANS_CMD_UPDATE_SELECTION) {
2007                         String text;
2008
2009                         if (m_recv_trans.get_data(text)) {
2010                             m_info_manager->socket_update_selection(text);
2011                         } else {
2012                             LOGW ("wrong format of transaction\n");
2013                         }
2014                     } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE)
2015                         m_info_manager->expand_candidate();
2016                     else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE)
2017                         m_info_manager->contract_candidate();
2018                     else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2019                         uint32 portrait_line, mode;
2020
2021                         if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2022                             m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2023                         else
2024                             LOGW ("wrong format of transaction\n");
2025                     } else if (cmd == SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO) {
2026                         PanelFactoryInfo info;
2027
2028                         if (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2029                             m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2030                             m_info_manager->socket_update_factory_info(info);
2031                         } else {
2032                             LOGW ("wrong format of transaction\n");
2033                         }
2034                     } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING)
2035                         m_info_manager->socket_show_preedit_string();
2036                     else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING)
2037                         m_info_manager->socket_show_aux_string();
2038                     else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE)
2039                         m_info_manager->socket_show_lookup_table();
2040                     else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE)
2041                         m_info_manager->socket_show_associate_table();
2042                     else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING)
2043                         m_info_manager->socket_hide_preedit_string();
2044                     else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING)
2045                         m_info_manager->socket_hide_aux_string();
2046                     else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE)
2047                         m_info_manager->socket_hide_lookup_table();
2048                     else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE)
2049                         m_info_manager->socket_hide_associate_table();
2050                     else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2051                         String str;
2052                         AttributeList attrs;
2053                         uint32 caret;
2054
2055                         if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs) && m_recv_trans.get_data(caret))
2056                             m_info_manager->socket_update_preedit_string(str, attrs, caret);
2057                         else
2058                             LOGW ("wrong format of transaction\n");
2059                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2060                         uint32 caret;
2061
2062                         if (m_recv_trans.get_data(caret))
2063                             m_info_manager->socket_update_preedit_caret(caret);
2064                         else
2065                             LOGW ("wrong format of transaction\n");
2066                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2067                         String str;
2068                         AttributeList attrs;
2069
2070                         if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2071                             m_info_manager->socket_update_aux_string(str, attrs);
2072                         else
2073                             LOGW ("wrong format of transaction\n");
2074                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2075                         CommonLookupTable _isf_candidate_table;
2076
2077                         if (m_recv_trans.get_data(_isf_candidate_table))
2078                             m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2079                         else
2080                             LOGW ("wrong format of transaction\n");
2081
2082                     } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2083                         CommonLookupTable table;
2084
2085                         if (m_recv_trans.get_data(table))
2086                             m_info_manager->socket_update_associate_table(table);
2087                         else
2088                             LOGW ("wrong format of transaction\n");
2089                     } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2090                         PropertyList properties;
2091
2092                         if (m_recv_trans.get_data(properties))
2093                             m_info_manager->socket_register_properties(properties);
2094                         else
2095                             LOGW ("wrong format of transaction\n");
2096                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2097                         Property property;
2098
2099                         if (m_recv_trans.get_data(property))
2100                             m_info_manager->socket_update_property(property);
2101                         else
2102                             LOGW ("wrong format of transaction\n");
2103                     } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_HELP) {
2104                         String help;
2105
2106                         if (m_recv_trans.get_data(help))
2107                             m_info_manager->socket_show_help(help);
2108                         else
2109                             LOGW ("wrong format of transaction\n");
2110                     } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU) {
2111                         PanelFactoryInfo info;
2112                         std::vector <PanelFactoryInfo> vec;
2113
2114                         while (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2115                                m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2116                             info.lang = scim_get_normalized_language(info.lang);
2117                             vec.push_back(info);
2118                         }
2119
2120                         m_info_manager->socket_show_factory_menu(vec);
2121                     } else if (cmd == SCIM_TRANS_CMD_FOCUS_OUT) {
2122                         m_info_manager->focus_out(client_id, context);
2123                     } else {
2124                         LOGW ("unknow cmd: %d\n", cmd);
2125                     }
2126                 }
2127
2128                 socket_transaction_end();
2129             }
2130         } else if (client_info.type == FRONTEND_CLIENT) {
2131             if (m_recv_trans.get_data(context)) {
2132                 SCIM_DEBUG_MAIN(1) << "client_info.type == FRONTEND_CLIENT\n";
2133                 socket_transaction_start();
2134
2135                 while (m_recv_trans.get_command(cmd)) {
2136                     LOGD ("PanelAgent::cmd = %d\n", cmd);
2137
2138                     if (cmd == ISM_TRANS_CMD_GET_PANEL_CLIENT_ID) {
2139                         Socket client_socket(client_id);
2140
2141                         Transaction trans;
2142                         trans.clear();
2143                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2144                         trans.put_command(SCIM_TRANS_CMD_OK);
2145                         trans.put_data(client_id);
2146                         trans.write_to_socket(client_socket);
2147                         continue;
2148                     } else {
2149                         LOGW ("unknow cmd: %d\n", cmd);
2150                     }
2151                 }
2152
2153                 socket_transaction_end();
2154             }
2155         } else if (client_info.type == HELPER_CLIENT) {
2156             socket_transaction_start();
2157
2158             while (m_recv_trans.get_command(cmd)) {
2159                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2160
2161                 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_HELPER) {
2162                     HelperInfo info;
2163
2164                     if (m_recv_trans.get_data(info.uuid) &&
2165                         m_recv_trans.get_data(info.name) &&
2166                         m_recv_trans.get_data(info.icon) &&
2167                         m_recv_trans.get_data(info.description) &&
2168                         m_recv_trans.get_data(info.option) &&
2169                         info.uuid.length()) {
2170                         m_info_manager->socket_helper_register_helper(client_id, info);
2171                     }
2172                 } else {
2173                     LOGW ("unknow cmd: %d\n", cmd);
2174                 }
2175             }
2176
2177             socket_transaction_end();
2178         } else if (client_info.type == HELPER_ACT_CLIENT) {
2179             socket_transaction_start();
2180
2181             while (m_recv_trans.get_command(cmd)) {
2182                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2183
2184                 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER) {
2185                     HelperInfo info;
2186
2187                     if (m_recv_trans.get_data(info.uuid) &&
2188                         m_recv_trans.get_data(info.name) &&
2189                         m_recv_trans.get_data(info.icon) &&
2190                         m_recv_trans.get_data(info.description) &&
2191                         m_recv_trans.get_data(info.option) &&
2192                         info.uuid.length()) {
2193                         m_info_manager->socket_helper_register_helper_passive(client_id, info);
2194                     } else {
2195                         LOGW ("wrong format of transaction\n");
2196                     }
2197                 } else if (cmd == SCIM_TRANS_CMD_COMMIT_STRING) {
2198                     uint32 target_ic;
2199                     String target_uuid;
2200                     WideString wstr;
2201
2202                     if (m_recv_trans.get_data(target_ic)    &&
2203                         m_recv_trans.get_data(target_uuid)  &&
2204                         m_recv_trans.get_data(wstr)         &&
2205                         wstr.length()) {
2206                         m_info_manager->socket_helper_commit_string(client_id, target_ic, target_uuid, wstr);
2207                     } else {
2208                         LOGW ("wrong format of transaction\n");
2209                     }
2210                 } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING) {
2211                     uint32 target_ic;
2212                     String target_uuid;
2213
2214                     if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2215                         m_info_manager->socket_helper_show_preedit_string(client_id, target_ic, target_uuid);
2216                     } else {
2217                         LOGW ("wrong format of transaction\n");
2218                     }
2219                 } else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING) {
2220                     m_info_manager->socket_show_aux_string();
2221                 } else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE) {
2222                     m_info_manager->socket_show_lookup_table();
2223                 } else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE) {
2224                     m_info_manager->socket_show_associate_table();
2225                 } else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING) {
2226                     uint32 target_ic;
2227                     String target_uuid;
2228
2229                     if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2230                         m_info_manager->socket_helper_hide_preedit_string(client_id, target_ic, target_uuid);
2231                     } else {
2232                         LOGW ("wrong format of transaction\n");
2233                     }
2234                 } else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING) {
2235                     m_info_manager->socket_hide_aux_string();
2236                 } else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE) {
2237                     m_info_manager->socket_hide_lookup_table();
2238                 } else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE) {
2239                     m_info_manager->socket_hide_associate_table();
2240                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2241                     uint32 target_ic;
2242                     String target_uuid;
2243                     WideString wstr;
2244                     AttributeList attrs;
2245                     uint32 caret;
2246
2247                     if (m_recv_trans.get_data(target_ic)    &&
2248                         m_recv_trans.get_data(target_uuid)  &&
2249                         m_recv_trans.get_data(wstr) &&
2250                         m_recv_trans.get_data(attrs) &&
2251                         m_recv_trans.get_data(caret)) {
2252                         m_info_manager->socket_helper_update_preedit_string(client_id, target_ic, target_uuid, wstr, attrs, caret);
2253                     } else {
2254                         LOGW ("wrong format of transaction\n");
2255                     }
2256                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2257                     uint32 caret;
2258
2259                     if (m_recv_trans.get_data(caret)) {
2260                         m_info_manager->socket_helper_update_preedit_caret(client_id, caret);
2261                     } else {
2262                         LOGW ("wrong format of transaction\n");
2263                     }
2264                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2265                     String str;
2266                     AttributeList attrs;
2267
2268                     if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2269                         m_info_manager->socket_update_aux_string(str, attrs);
2270                     else
2271                         LOGW ("wrong format of transaction\n");
2272
2273                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2274                     CommonLookupTable _isf_candidate_table;
2275
2276                     if (m_recv_trans.get_data(_isf_candidate_table)) {
2277                         m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2278                     } else {
2279                         LOGW ("wrong format of transaction\n");
2280                     }
2281                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2282                     CommonLookupTable _isf_candidate_table;
2283
2284                     if (m_recv_trans.get_data(_isf_candidate_table)) {
2285                         m_info_manager->socket_update_associate_table(_isf_candidate_table);
2286                     } else {
2287                         LOGW ("wrong format of transaction\n");
2288                     }
2289                 } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT ||
2290                            cmd == SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT) {
2291                     uint32 target_ic;
2292                     String target_uuid;
2293                     KeyEvent key;
2294
2295                     if (m_recv_trans.get_data(target_ic)    &&
2296                         m_recv_trans.get_data(target_uuid)  &&
2297                         m_recv_trans.get_data(key)          &&
2298                         !key.empty()) {
2299                         m_info_manager->socket_helper_send_key_event(client_id, target_ic, target_uuid, key);
2300                     } else {
2301                         LOGW ("wrong format of transaction\n");
2302                     }
2303                 } else if (cmd == SCIM_TRANS_CMD_FORWARD_KEY_EVENT) {
2304                     uint32 target_ic;
2305                     String target_uuid;
2306                     KeyEvent key;
2307
2308                     if (m_recv_trans.get_data(target_ic)    &&
2309                         m_recv_trans.get_data(target_uuid)  &&
2310                         m_recv_trans.get_data(key)          &&
2311                         !key.empty()) {
2312                         m_info_manager->socket_helper_forward_key_event(client_id, target_ic, target_uuid, key);
2313                     } else {
2314                         LOGW ("wrong format of transaction\n");
2315                     }
2316                 } else if (cmd == SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT) {
2317                     uint32 target_ic;
2318                     String target_uuid;
2319
2320                     if (m_recv_trans.get_data(target_ic)    &&
2321                         m_recv_trans.get_data(target_uuid)  &&
2322                         m_recv_trans.get_data(m_nest_trans) &&
2323                         m_nest_trans.valid()) {
2324                         m_info_manager->socket_helper_send_imengine_event(client_id, target_ic, target_uuid, m_nest_trans);
2325                     } else {
2326                         LOGW ("wrong format of transaction\n");
2327                     }
2328                 } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2329                     PropertyList properties;
2330
2331                     if (m_recv_trans.get_data(properties))
2332                         m_info_manager->socket_helper_register_properties(client_id, properties);
2333                     else
2334                         LOGW ("wrong format of transaction\n");
2335                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2336                     Property property;
2337
2338                     if (m_recv_trans.get_data(property))
2339                         m_info_manager->socket_helper_update_property(client_id, property);
2340                     else
2341                         LOGW ("wrong format of transaction\n");
2342                 } else if (cmd == SCIM_TRANS_CMD_RELOAD_CONFIG) {
2343                     m_info_manager->reload_config();
2344                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT) {
2345                     uint32 type;
2346                     uint32 value;
2347
2348                     if (m_recv_trans.get_data(type) && m_recv_trans.get_data(value)) {
2349                         m_info_manager->socket_helper_update_input_context(client_id, type, value);
2350                     } else {
2351                         LOGW ("wrong format of transaction\n");
2352                     }
2353                 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST) {
2354                     String uuid;
2355
2356                     if (m_recv_trans.get_data(uuid)) {
2357                         m_info_manager->socket_get_keyboard_ise_list(uuid);
2358                     } else {
2359                         LOGW ("wrong format of transaction\n");
2360                     }
2361                 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2362                     uint32 portrait_line, mode;
2363
2364                     if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2365                         m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2366                     else
2367                         LOGW ("wrong format of transaction\n");
2368                 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_UI) {
2369                     String uuid;
2370
2371                     if (m_recv_trans.get_data(uuid)) {
2372                         m_info_manager->socket_get_candidate_ui(uuid);
2373                     } else {
2374                         LOGW ("wrong format of transaction\n");
2375                     }
2376                 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_POSITION) {
2377                     uint32 left, top;
2378
2379                     if (m_recv_trans.get_data(left) && m_recv_trans.get_data(top))
2380                         m_info_manager->socket_set_candidate_position(left, top);
2381                     else
2382                         LOGW ("wrong format of transaction\n");
2383                 } else if (cmd == ISM_TRANS_CMD_HIDE_CANDIDATE) {
2384                     m_info_manager->socket_hide_candidate();
2385                 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
2386                     String uuid;
2387
2388                     if (m_recv_trans.get_data(uuid)) {
2389                         m_info_manager->socket_get_candidate_geometry(uuid);
2390                     } else {
2391                         LOGW ("wrong format of transaction\n");
2392                     }
2393                 } else if (cmd == ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE) {
2394                     m_info_manager->reset_keyboard_ise();
2395                 } else if (cmd == ISM_TRANS_CMD_SET_KEYBOARD_ISE_BY_UUID) {
2396                     String uuid;
2397
2398                     if (m_recv_trans.get_data(uuid)) {
2399                         m_info_manager->socket_set_keyboard_ise(uuid);
2400                     } else {
2401                         LOGW ("wrong format of transaction\n");
2402                     }
2403                 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE) {
2404                     String uuid;
2405
2406                     if (m_recv_trans.get_data(uuid)) {
2407                         m_info_manager->socket_get_keyboard_ise(uuid);
2408                     } else {
2409                         LOGW ("wrong format of transaction\n");
2410                     }
2411                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY) {
2412                     uint32 x, y, width, height;
2413
2414                     if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) &&
2415                         m_recv_trans.get_data(width) && m_recv_trans.get_data(height)) {
2416                         m_info_manager->socket_helper_update_ise_geometry(client_id, x, y, width, height);
2417                     } else {
2418                         LOGW ("wrong format of transaction\n");
2419                     }
2420                 } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE) {
2421                     m_info_manager->expand_candidate();
2422                 } else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE) {
2423                     m_info_manager->contract_candidate();
2424                 } else if (cmd == ISM_TRANS_CMD_SELECT_CANDIDATE) {
2425                     uint32 index;
2426
2427                     if (m_recv_trans.get_data(index))
2428                         m_info_manager->socket_helper_select_candidate(index);
2429                     else
2430                         LOGW ("wrong format of transaction\n");
2431                 } else if (cmd == SCIM_TRANS_CMD_GET_SURROUNDING_TEXT) {
2432                     String uuid;
2433                     uint32 maxlen_before;
2434                     uint32 maxlen_after;
2435
2436                     if (m_recv_trans.get_data(uuid) &&
2437                         m_recv_trans.get_data(maxlen_before) &&
2438                         m_recv_trans.get_data(maxlen_after)) {
2439                         m_info_manager->socket_helper_get_surrounding_text(client_id, uuid, maxlen_before, maxlen_after);
2440                     } else {
2441                         LOGW ("wrong format of transaction\n");
2442                     }
2443                 } else if (cmd == SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
2444                     uint32 offset;
2445                     uint32 len;
2446
2447                     if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
2448                         m_info_manager->socket_helper_delete_surrounding_text(client_id, offset, len);
2449                     } else {
2450                         LOGW ("wrong format of transaction\n");
2451                     }
2452                 } else if (cmd == SCIM_TRANS_CMD_GET_SELECTION) {
2453                     String uuid;
2454
2455                     if (m_recv_trans.get_data(uuid)) {
2456                         m_info_manager->socket_helper_get_selection(client_id, uuid);
2457                     } else {
2458                         LOGW ("wrong format of transaction\n");
2459                     }
2460                 } else if (cmd == SCIM_TRANS_CMD_SET_SELECTION) {
2461                     uint32 start;
2462                     uint32 end;
2463
2464                     if (m_recv_trans.get_data(start) && m_recv_trans.get_data(end)) {
2465                         m_info_manager->socket_helper_set_selection(client_id, start, end);
2466                     } else {
2467                         LOGW ("wrong format of transaction\n");
2468                     }
2469                 } else if (cmd == SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND) {
2470                     String command;
2471
2472                     if (m_recv_trans.get_data(command)) {
2473                         m_info_manager->socket_helper_send_private_command(client_id, command);
2474                     } else {
2475                         LOGW ("wrong format of transaction\n");
2476                     }
2477                 //FIXME: useless
2478                 //} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_EXIT) {
2479                 //    m_info_manager->UPDATE_ISE_EXIT(client_id);
2480                 } else {
2481                     LOGW ("unknow cmd: %d\n", cmd);
2482                 }
2483             }
2484
2485             socket_transaction_end();
2486         } else if (client_info.type == IMCONTROL_ACT_CLIENT) {
2487             socket_transaction_start();
2488
2489             while (m_recv_trans.get_command(cmd)) {
2490                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2491
2492                 if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE) {
2493
2494                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2495                         String default_uuid;
2496                         m_info_manager->get_active_ise(client_id, default_uuid);
2497                         Transaction trans;
2498                         Socket client_socket(client_id);
2499
2500                         trans.clear();
2501                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2502                         trans.put_command(SCIM_TRANS_CMD_OK);
2503                         trans.put_data(default_uuid);
2504                         trans.write_to_socket(client_socket);
2505                     }
2506                     else {
2507                         LOGW ("Access denied to get active ise\n");
2508                         send_fail_reply (client_id);
2509                     }
2510                 } else if (cmd == ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID) {
2511                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2512                         char*   buf = NULL;
2513                         size_t  len;
2514                         bool ret = false;
2515
2516                         if (m_recv_trans.get_data(&buf, len)) {
2517                             ret = m_info_manager->set_active_ise_by_uuid(client_id, buf, len);
2518                         } else {
2519                             LOGW ("wrong format of transaction\n");
2520                         }
2521
2522                         Transaction trans;
2523                         Socket client_socket(client_id);
2524
2525                         trans.clear();
2526                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2527                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2528                         trans.write_to_socket(client_socket);
2529
2530                         if (NULL != buf)
2531                             delete[] buf;
2532                     }
2533                     else {
2534                         LOGW ("Access denied to set active ise\n");
2535                         send_fail_reply (client_id);
2536                     }
2537                 } else if (cmd == ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID) {
2538                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2539                         char*   buf = NULL;
2540                         size_t  len;
2541                         bool ret = true;
2542
2543                         //FIXME
2544                         //ret need be checked
2545                         if (m_recv_trans.get_data(&buf, len)) {
2546                             m_info_manager->set_initial_ise_by_uuid(client_id, buf, len);
2547                         } else {
2548                             LOGW ("wrong format of transaction\n");
2549                         }
2550
2551                         Transaction trans;
2552                         Socket client_socket(client_id);
2553
2554                         trans.clear();
2555                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2556                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2557                         trans.write_to_socket(client_socket);
2558
2559                         if (NULL != buf)
2560                             delete[] buf;
2561                     }
2562                     else {
2563                         LOGW ("Access denied to set initial ise\n");
2564                         send_fail_reply (client_id);
2565                     }
2566                 } else if (cmd == ISM_TRANS_CMD_GET_ISE_LIST) {
2567                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2568                         std::vector<String> strlist;
2569                         m_info_manager->get_ise_list(client_id, strlist);
2570                         Transaction trans;
2571                         Socket client_socket(client_id);
2572                         char* buf = NULL;
2573                         size_t len;
2574                         uint32 num;
2575
2576                         trans.clear();
2577                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2578                         trans.put_command(SCIM_TRANS_CMD_OK);
2579
2580                         num = strlist.size();
2581                         trans.put_data(num);
2582
2583                         for (unsigned int i = 0; i < num; i++) {
2584                             buf = const_cast<char*>(strlist[i].c_str());
2585                             len = strlen(buf) + 1;
2586                             trans.put_data(buf, len);
2587                         }
2588
2589                         trans.write_to_socket(client_socket);
2590                     }
2591                     else {
2592                         LOGW ("Access denied to get ise list\n");
2593                         send_fail_reply (client_id);
2594                     }
2595                 } else if (cmd == ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO) {
2596                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2597                         HELPER_ISE_INFO info;
2598                         m_info_manager->get_all_helper_ise_info(client_id, info);
2599
2600                         do {
2601                             Transaction trans;
2602                             Socket client_socket(client_id);
2603
2604                             trans.clear();
2605                             trans.put_command(SCIM_TRANS_CMD_REPLY);
2606                             trans.put_command(SCIM_TRANS_CMD_OK);
2607
2608                             if (info.appid.size() > 0) {
2609                                 trans.put_data(info.appid);
2610                                 trans.put_data(info.label);
2611                                 trans.put_data(info.is_enabled);
2612                                 trans.put_data(info.is_preinstalled);
2613                                 trans.put_data(info.has_option);
2614                             }
2615
2616                             trans.write_to_socket(client_socket);
2617                         } while (0);
2618                     }
2619                     else {
2620                         LOGW ("Access denied to get all helper ise info\n");
2621                         send_fail_reply (client_id);
2622                     }
2623                 } else if (cmd == ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO) {
2624                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2625                         String appid;
2626                         uint32 is_enabled;
2627                         bool ret = false;
2628
2629                         if (m_recv_trans.get_data(appid) && appid.length() != 0 && m_recv_trans.get_data(is_enabled)) {
2630                             m_info_manager->set_enable_helper_ise_info(client_id, appid, is_enabled);
2631                             ret = true;
2632                         } else {
2633                             LOGW ("wrong format of transaction\n");
2634                         }
2635
2636                         Transaction trans;
2637                         Socket client_socket(client_id);
2638
2639                         trans.clear();
2640                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2641                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2642                         trans.write_to_socket(client_socket);
2643                     }
2644                     else {
2645                         LOGW ("Access denied to set enable helper ise info\n");
2646                         send_fail_reply (client_id);
2647                     }
2648                 } else if (cmd == ISM_TRANS_CMD_GET_ISE_INFORMATION) {
2649                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2650                         String strUuid, strName, strLanguage, strModuleName;
2651                         int nType   = 0;
2652                         int nOption = 0;
2653
2654                         if (m_recv_trans.get_data(strUuid)) {
2655                             m_info_manager->get_ise_information(client_id, strUuid, strName, strLanguage, nType, nOption, strModuleName);
2656                         } else {
2657                             LOGW ("wrong format of transaction\n");
2658                         }
2659
2660                         Transaction trans;
2661                         Socket client_socket(client_id);
2662                         trans.clear();
2663                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2664                         trans.put_command(SCIM_TRANS_CMD_OK);
2665                         trans.put_data(strName);
2666                         trans.put_data(strLanguage);
2667                         trans.put_data(nType);
2668                         trans.put_data(nOption);
2669                         trans.put_data(strModuleName);
2670                         trans.write_to_socket(client_socket);
2671                     }
2672                     else {
2673                         LOGW ("Access denied to get ise information\n");
2674                         send_fail_reply (client_id);
2675                     }
2676                 } else if (cmd == ISM_TRANS_CMD_RESET_ISE_OPTION) {
2677                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2678                         Transaction trans;
2679                         Socket client_socket(client_id);
2680
2681                         trans.clear();
2682                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2683                         trans.put_command(SCIM_TRANS_CMD_OK);
2684                         trans.write_to_socket(client_socket);
2685                         m_info_manager->show_helper_ise_selector(client_id);
2686                         m_info_manager->reset_ise_option(client_id);
2687                     }
2688                     else {
2689                         LOGW ("Access denied to reset ise option\n");
2690                         send_fail_reply (client_id);
2691                     }
2692                 } else if (cmd == ISM_TRANS_CMD_RESET_DEFAULT_ISE) {
2693                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2694                         m_info_manager->reset_default_ise(client_id);
2695                     }
2696                     else {
2697                         LOGW ("Access denied to reset default ise\n");
2698                         send_fail_reply (client_id);
2699                     }
2700                 } else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
2701                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2702                         m_info_manager->show_isf_panel(client_id);
2703                     }
2704                     else {
2705                         LOGW ("Access denied to show isf control\n");
2706                         send_fail_reply (client_id);
2707                     }
2708                 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
2709                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2710                         m_info_manager->show_ise_option_window(client_id);
2711                     }
2712                     else {
2713                         LOGW ("Access denied to show ise option window\n");
2714                         send_fail_reply (client_id);
2715                     }
2716                 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST) {
2717                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2718                         Transaction trans;
2719                         Socket client_socket(client_id);
2720
2721                         trans.clear();
2722                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2723                         trans.put_command(SCIM_TRANS_CMD_OK);
2724                         trans.write_to_socket(client_socket);
2725
2726                         m_info_manager->show_helper_ise_list(client_id);
2727                     }
2728                     else {
2729                         LOGW ("Access denied to show helper ise list\n");
2730                         send_fail_reply (client_id);
2731                     }
2732                 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR) {
2733                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2734                         Transaction trans;
2735                         Socket client_socket(client_id);
2736
2737                         trans.clear();
2738                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2739                         trans.put_command(SCIM_TRANS_CMD_OK);
2740                         trans.write_to_socket(client_socket);
2741                         m_info_manager->show_helper_ise_selector(client_id);
2742                     }
2743                     else {
2744                         LOGW ("Access denied to show helper ise selector\n");
2745                         send_fail_reply (client_id);
2746                     }
2747                 } else if (cmd == ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED) {
2748                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2749                         String strAppid;
2750                         uint32 nEnabled = 0;
2751                         bool ret = true;
2752                         //FIXME
2753                         //ret need be checked
2754                         m_info_manager->is_helper_ise_enabled(client_id, strAppid, nEnabled);
2755                         Transaction trans;
2756                         Socket client_socket(client_id);
2757                         trans.clear();
2758                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2759
2760                         if (ret) {
2761                             trans.put_command(SCIM_TRANS_CMD_OK);
2762                             trans.put_data(static_cast<uint32>(nEnabled));
2763                         } else {
2764                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2765                         }
2766
2767                         trans.write_to_socket(client_socket);
2768                     }
2769                     else {
2770                         LOGW ("Access denied to check helper ise enabled\n");
2771                         send_fail_reply (client_id);
2772                     }
2773                 } else if (cmd == ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY) {
2774                     uint32 angle;
2775
2776                     Transaction trans;
2777                     Socket client_socket(client_id);
2778
2779                     trans.clear();
2780                     trans.put_command(SCIM_TRANS_CMD_REPLY);
2781
2782                     if (m_recv_trans.get_data(angle)) {
2783                         struct rectinfo info = {0, 0, 0, 0};
2784                         m_info_manager->get_recent_ise_geometry(client_id, angle, info);
2785
2786                         trans.put_command(SCIM_TRANS_CMD_OK);
2787                         trans.put_data(info.pos_x);
2788                         trans.put_data(info.pos_y);
2789                         trans.put_data(info.width);
2790                         trans.put_data(info.height);
2791                     } else {
2792                         trans.put_command(SCIM_TRANS_CMD_FAIL);
2793                     }
2794
2795                     trans.write_to_socket(client_socket);
2796                 } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
2797                     Transaction trans;
2798                     Socket client_socket(client_id);
2799
2800                     trans.clear();
2801                     trans.put_command(SCIM_TRANS_CMD_REPLY);
2802                     trans.put_command(SCIM_TRANS_CMD_OK);
2803                     trans.write_to_socket(client_socket);
2804                     m_info_manager->hide_helper_ise ();
2805                 } else {
2806                     LOGW ("unknow cmd: %d\n", cmd);
2807                 }
2808             }
2809
2810             socket_transaction_end();
2811         }
2812     }
2813
2814     void socket_exception_callback(SocketServer*   server,
2815                                    const Socket&   client) {
2816         SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_exception_callback (" << client.get_id() << ")\n";
2817         LOGD ("client id:%d\n", client.get_id());
2818         socket_close_connection(server, client);
2819     }
2820
2821     bool socket_open_connection(SocketServer*   server,
2822                                 const Socket&   client) {
2823         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_open_connection (" << client.get_id() << ")\n";
2824         LOGD ("client id:%d\n", client.get_id());
2825         uint32 key;
2826         String type = scim_socket_accept_connection(key,
2827                       String("Panel"),
2828                       String("FrontEnd,FrontEnd_Active,Helper,Helper_Active,IMControl_Active,IMControl_Passive"),
2829                       client,
2830                       m_socket_timeout);
2831
2832         if (type.length()) {
2833             ClientType _type = ((type == "FrontEnd") ? FRONTEND_CLIENT :
2834                                 ((type == "FrontEnd_Active") ? FRONTEND_ACT_CLIENT :
2835                                  ((type == "IMControl_Active") ? IMCONTROL_ACT_CLIENT :
2836                                   ((type == "Helper_Active") ? HELPER_ACT_CLIENT :
2837                                    ((type == "IMControl_Passive") ? IMCONTROL_CLIENT : HELPER_CLIENT)))));
2838             lock();
2839             m_info_manager->add_client(client.get_id(), key, _type);
2840             unlock();
2841             return true;
2842         }
2843         LOGW ("open_connection failed\n");
2844
2845         SCIM_DEBUG_MAIN(4) << "Close client connection " << client.get_id() << "\n";
2846         server->close_connection(client);
2847         return false;
2848     }
2849
2850     void socket_close_connection(SocketServer*   server,
2851                                  const Socket&   client) {
2852         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_close_connection (" << client.get_id() << ")\n";
2853         LOGD ("client id:%d\n", client.get_id());
2854         int i = 0;
2855         std::vector<Ecore_Fd_Handler *>::iterator IterPos;
2856
2857         for (IterPos = _read_handler_list.begin (); IterPos != _read_handler_list.end (); ++IterPos,++i) {
2858             if (ecore_main_fd_handler_fd_get (_read_handler_list[i]) == client.get_id()) {
2859                 ecore_main_fd_handler_del (_read_handler_list[i]);
2860                 _read_handler_list.erase (IterPos);
2861                 break;
2862             }
2863         }
2864         m_info_manager->del_client(client.get_id());
2865     }
2866
2867     void socket_transaction_start(void) {
2868         //m_signal_transaction_start ();
2869     }
2870
2871     void socket_transaction_end(void) {
2872         //m_signal_transaction_end ();
2873     }
2874
2875     void lock(void) {
2876         //m_signal_lock ();
2877     }
2878     void unlock(void) {
2879         //m_signal_unlock ();
2880     }
2881 };
2882
2883 } /* namespace scim */
2884
2885 /***************************************************/
2886 /*** Beginning of panel agent interface for ISF ***/
2887 /***************************************************/
2888 static scim::PanelAgentPointer instance;
2889
2890 extern "C" {
2891
2892     EXAPI void scim_module_init(void)
2893     {
2894     }
2895
2896     EXAPI void scim_module_exit(void)
2897     {
2898         instance.reset();
2899     }
2900
2901     EXAPI void scim_panel_agent_module_init(const scim::ConfigPointer& config)
2902     {
2903     }
2904
2905     EXAPI scim::PanelAgentPointer scim_panel_agent_module_get_instance()
2906     {
2907         scim::PanelAgentBase* _instance = NULL;
2908         if (instance.null()) {
2909             try {
2910                 _instance = new scim::EcoreSocketPanelAgent();
2911             } catch (...) {
2912                 delete _instance;
2913                 _instance = NULL;
2914             }
2915             if(_instance)
2916                 instance = _instance;
2917         }
2918         return instance;
2919     }
2920 }
2921
2922 /*
2923 vi:ts=4:nowrap:ai:expandtab
2924 */