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