ism/src/scim_panel_agent.cpp

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