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