ism/src/isf_imcontrol_client.cpp

   1 /*
   2  * ISF(Input Service Framework)
   3  *
   4  * ISF is based on SCIM 1.4.7 and extended for supporting more mobile fitable.
   5  * Copyright (c) 2012-2015 Samsung Electronics Co., Ltd.
   6  *
   7  * Contact: Haifeng Deng <haifeng.deng@samsung.com>, Hengliang Luo <hl.luo@samsung.com>
   8  *
   9  * This library is free software; you can redistribute it and/or modify it under
  10  * the terms of the GNU Lesser General Public License as published by the
  11  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  12  * any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  15  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  17  * License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  21  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  *
  23  */
  24
  25 #define Uses_SCIM_TRANSACTION
  26 #define Uses_ISF_IMCONTROL_CLIENT
  27 #define Uses_SCIM_PANEL_AGENT
  28 #define Uses_SCIM_IMENGINE_MODULE
  29 #define Uses_SCIM_HELPER_MODULE
  30
  31 #include <string.h>
  32 #include "scim.h"
  33
  34
  35 namespace scim
  36 {
  37
  38 typedef Signal1<void, int> IMControlClientSignalVoid;
  39
  40 #if ENABLE_LAZY_LAUNCH
  41 static bool check_panel (const String &display)
  42 {
  43     SocketAddress address;
  44     SocketClient client;
  45
  46     uint32 magic;
  47
  48     address.set_address (scim_get_default_panel_socket_address (display));
  49
  50     if (!client.connect (address))
  51         return false;
  52
  53     if (!scim_socket_open_connection (magic,
  54         String ("ConnectionTester"),
  55         String ("Panel"),
  56         client,
  57         1000)) {
  58         return false;
  59     }
  60
  61     return true;
  62 }
  63
  64 static bool
  65 check_socket_frontend (void)
  66 {
  67     SCIM_DEBUG_FRONTEND(1) << __FUNCTION__ << "...\n";
  68
  69     SocketAddress address;
  70     SocketClient client;
  71
  72     uint32 magic;
  73
  74     address.set_address (scim_get_default_socket_frontend_address ());
  75
  76     if (!client.connect (address)) {
  77         std::cerr << "check_socket_frontend's connect () failed.\n";
  78         return false;
  79     }
  80
  81     if (!scim_socket_open_connection (magic,
  82                                       String ("ConnectionTester"),
  83                                       String ("SocketFrontEnd"),
  84                                       client,
  85                                       500)) {
  86         std::cerr << "check_socket_frontend's scim_socket_open_connection () failed.\n";
  87         return false;
  88     }
  89
  90     return true;
  91 }
  92
  93 static int
  94 launch_socket_frontend ()
  95 {
  96     SCIM_DEBUG_FRONTEND(1) << __FUNCTION__ << "...\n";
  97
  98     std::vector<String>     engine_list;
  99     std::vector<String>     helper_list;
 100     std::vector<String>     load_engine_list;
 101
 102     std::vector<String>::iterator it;
 103
 104     std::cerr << "Launching a ISF daemon with Socket FrontEnd...\n";
 105     //get modules list
 106     scim_get_imengine_module_list (engine_list);
 107     scim_get_helper_module_list (helper_list);
 108
 109     for (it = engine_list.begin (); it != engine_list.end (); it++) {
 110         if (*it != "socket")
 111             load_engine_list.push_back (*it);
 112     }
 113     for (it = helper_list.begin (); it != helper_list.end (); it++)
 114         load_engine_list.push_back (*it);
 115
 116     return scim_launch (true,
 117         "simple",
 118         (load_engine_list.size () > 0 ? scim_combine_string_list (load_engine_list, ',') : "none"),
 119         "socket",
 120         NULL);
 121 }
 122 #endif
 123
 124 class IMControlClient::IMControlClientImpl
 125 {
 126     SocketClient                                m_socket_imclient2panel;
 127     SocketClient                                m_socket_panel2imclient;
 128     int                                         m_socket_timeout;
 129     uint32                                      m_socket_i2p_magic_key;
 130     uint32                                      m_socket_p2i_magic_key;
 131     Transaction                                 m_trans;
 132
 133     IMControlClientSignalVoid                   m_signal_show_ise;
 134     IMControlClientSignalVoid                   m_signal_hide_ise;
 135
 136 public:
 137     IMControlClientImpl ()
 138           : m_socket_timeout (scim_get_default_socket_timeout ()),
 139             m_socket_i2p_magic_key (0),
 140             m_socket_p2i_magic_key (0) {
 141     }
 142
 143     int open_connection (void) {
 144         const char *p = getenv ("DISPLAY");
 145         String display;
 146         if (p) display = String (p);
 147
 148         SocketAddress addr (scim_get_default_panel_socket_address (display));
 149
 150         if (m_socket_imclient2panel.is_connected ()) close_connection ();
 151
 152         bool ret = false, ret2 = false;
 153         int count = 0;
 154
 155         /* Try three times. */
 156         while (1) {
 157             ret = m_socket_imclient2panel.connect (addr);
 158             ret2 = m_socket_panel2imclient.connect (addr);
 159             if (!ret) {
 160                 scim_usleep (100000);
 161 #if ENABLE_LAZY_LAUNCH
 162                 if (!check_socket_frontend ())
 163                     launch_socket_frontend ();
 164                 if (!check_panel (display))
 165                     scim_launch_panel (true, "socket", display, NULL);
 166 #endif
 167                 for (int i = 0; i < 200; ++i) {
 168                     if (m_socket_imclient2panel.connect (addr)) {
 169                         ret = true;
 170                         break;
 171                     }
 172                     scim_usleep (100000);
 173                 }
 174             }
 175
 176             if (ret && scim_socket_open_connection (m_socket_i2p_magic_key, String ("IMControl_Active"), String ("Panel"), m_socket_imclient2panel, m_socket_timeout)) {
 177                 if (ret2 && scim_socket_open_connection (m_socket_p2i_magic_key, String ("IMControl_Passive"), String ("Panel"), m_socket_panel2imclient, m_socket_timeout))
 178                     break;
 179             }
 180             m_socket_imclient2panel.close ();
 181             m_socket_panel2imclient.close ();
 182
 183             if (count++ >= 3) break;
 184
 185             scim_usleep (100000);
 186         }
 187
 188         return m_socket_imclient2panel.get_id ();
 189     }
 190
 191     void close_connection (void) {
 192         m_socket_imclient2panel.close ();
 193         m_socket_panel2imclient.close ();
 194         m_socket_i2p_magic_key = 0;
 195         m_socket_p2i_magic_key = 0;
 196     }
 197
 198     bool is_connected (void) const {
 199         return (m_socket_imclient2panel.is_connected () && m_socket_panel2imclient.is_connected ());
 200     }
 201
 202     int  get_panel2imclient_connection_number  (void) const {
 203         return m_socket_panel2imclient.get_id ();
 204     }
 205
 206     bool prepare (void) {
 207         if (!m_socket_imclient2panel.is_connected ()) return false;
 208
 209         m_trans.clear ();
 210         m_trans.put_command (SCIM_TRANS_CMD_REQUEST);
 211         m_trans.put_data (m_socket_i2p_magic_key);
 212
 213         return true;
 214     }
 215
 216     bool send (void) {
 217         if (!m_socket_imclient2panel.is_connected ()) return false;
 218         if (m_trans.get_data_type () != SCIM_TRANS_DATA_UNKNOWN)
 219             return m_trans.write_to_socket (m_socket_imclient2panel, 0x4d494353);
 220         return false;
 221     }
 222
 223     bool set_active_ise_by_uuid (const char* uuid) {
 224         int cmd;
 225         m_trans.put_command (ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID);
 226         m_trans.put_data (uuid, strlen (uuid)+1);
 227         m_trans.write_to_socket (m_socket_imclient2panel);
 228         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 229             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 230             return false;
 231         }
 232
 233         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 234                 m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
 235         } else {
 236             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 237             return false;
 238         }
 239
 240         return true;
 241     }
 242
 243     bool set_initial_ise_by_uuid (const char* uuid) {
 244         int cmd;
 245         m_trans.put_command (ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID);
 246         m_trans.put_data (uuid, strlen (uuid)+1);
 247         m_trans.write_to_socket (m_socket_imclient2panel);
 248         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 249             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 250             return false;
 251         }
 252
 253         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 254                 m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
 255         } else {
 256             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 257             return false;
 258         }
 259
 260         return true;
 261     }
 262
 263     bool get_active_ise (String &uuid) {
 264         int    cmd;
 265         String strTemp;
 266
 267         m_trans.put_command (ISM_TRANS_CMD_GET_ACTIVE_ISE);
 268         m_trans.write_to_socket (m_socket_imclient2panel);
 269         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 270             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 271             return false;
 272         }
 273
 274         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 275                 m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK &&
 276                 m_trans.get_data (strTemp)) {
 277             uuid = strTemp;
 278         } else {
 279             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 280             return false;
 281         }
 282
 283         return true;
 284     }
 285
 286     bool get_ise_list (int* count, char*** iselist) {
 287         int cmd;
 288         uint32 count_temp = 0;
 289         char **buf = NULL;
 290         size_t len;
 291         char *buf_temp = NULL;
 292
 293         m_trans.put_command (ISM_TRANS_CMD_GET_ISE_LIST);
 294         m_trans.write_to_socket (m_socket_imclient2panel);
 295         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 296             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 297             return false;
 298         }
 299
 300         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 301                 m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK &&
 302                 m_trans.get_data (count_temp) ) {
 303             if (count)
 304                 *count = count_temp;
 305         } else {
 306             if (count)
 307                 *count = 0;
 308             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 309             return false;
 310         }
 311
 312         if (iselist) {
 313             if (count_temp > 0) {
 314                 buf = (char**)calloc (1, count_temp * sizeof (char*));
 315                 if (buf) {
 316                     for (uint32 i = 0; i < count_temp; i++) {
 317                         if (m_trans.get_data (&buf_temp, len)) {
 318                             if (buf_temp) {
 319                                 buf[i] = strdup (buf_temp);
 320                                 delete [] buf_temp;
 321                             }
 322                         }
 323                     }
 324                 }
 325             }
 326
 327             *iselist = buf;
 328         }
 329
 330         return true;
 331     }
 332
 333     bool get_ise_info (const char* uuid, String &name, String &language, int &type, int &option, String &module_name)
 334     {
 335         int    cmd;
 336         uint32 tmp_type, tmp_option;
 337         String tmp_name, tmp_language, tmp_module_name;
 338
 339         m_trans.put_command (ISM_TRANS_CMD_GET_ISE_INFORMATION);
 340         m_trans.put_data (String (uuid));
 341         m_trans.write_to_socket (m_socket_imclient2panel);
 342         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 343             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 344             return false;
 345         }
 346
 347         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 348                 m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK &&
 349                 m_trans.get_data (tmp_name) && m_trans.get_data (tmp_language) &&
 350                 m_trans.get_data (tmp_type) && m_trans.get_data (tmp_option) && m_trans.get_data (tmp_module_name)) {
 351             name     = tmp_name;
 352             language = tmp_language;
 353             type     = tmp_type;
 354             option   = tmp_option;
 355             module_name = tmp_module_name;
 356
 357             return true;
 358         } else {
 359             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 360             return false;
 361         }
 362     }
 363
 364     bool reset_ise_option (void) {
 365         int cmd;
 366
 367         m_trans.put_command (ISM_TRANS_CMD_RESET_ISE_OPTION);
 368         m_trans.write_to_socket (m_socket_imclient2panel);
 369         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 370             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 371             return false;
 372         }
 373
 374         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 375                 m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
 376             return true;
 377         } else {
 378             std::cerr << __func__ << " get_command() is failed!!!\n";
 379             return false;
 380         }
 381     }
 382
 383     void set_active_ise_to_default (void) {
 384         m_trans.put_command (ISM_TRANS_CMD_RESET_DEFAULT_ISE);
 385     }
 386
 387     void show_ise_selector (void) {
 388         m_trans.put_command (ISM_TRANS_CMD_SHOW_ISF_CONTROL);
 389     }
 390
 391     void show_ise_option_window (void) {
 392         m_trans.put_command (ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW);
 393     }
 394
 395     void resume_ise_option_window (void) {
 396         m_trans.put_command (ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW);
 397     }
 398
 399     bool get_all_helper_ise_info (HELPER_ISE_INFO &info) {
 400         int cmd;
 401         std::vector<String> appid;
 402         std::vector<String> label;
 403         std::vector<uint32> is_enabled;
 404         std::vector<uint32> is_preinstalled;
 405         std::vector<uint32> has_option;
 406
 407         info.appid.clear ();
 408         info.label.clear ();
 409         info.is_enabled.clear ();
 410         info.is_preinstalled.clear ();
 411         info.has_option.clear ();
 412
 413         m_trans.put_command (ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO);
 414         m_trans.write_to_socket (m_socket_imclient2panel);
 415         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 416             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 417             return false;
 418         }
 419
 420         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 421                 m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK &&
 422                 m_trans.get_data (appid) ) {
 423         } else {
 424             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 425             return false;
 426         }
 427
 428         if (appid.size () > 0) {
 429             m_trans.get_data (label);
 430             m_trans.get_data (is_enabled);
 431             m_trans.get_data (is_preinstalled);
 432             m_trans.get_data (has_option);
 433             if (appid.size () == label.size () && appid.size () == is_enabled.size () && appid.size () == is_preinstalled.size () && appid.size () == has_option.size ()) {
 434                 info.appid = appid;
 435                 info.label = label;
 436                 info.is_enabled = is_enabled;
 437                 info.is_preinstalled = is_preinstalled;
 438                 info.has_option = has_option;
 439                 return true;
 440             }
 441         }
 442
 443         return false;
 444     }
 445
 446     bool set_enable_helper_ise_info (const char *appid, bool is_enabled) {
 447         int cmd;
 448
 449         if (!appid)
 450             return false;
 451
 452         m_trans.put_command (ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO);
 453         m_trans.put_data (String (appid));
 454         m_trans.put_data (static_cast<uint32>(is_enabled));
 455         m_trans.write_to_socket (m_socket_imclient2panel);
 456         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 457             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 458             return false;
 459         }
 460
 461         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 462             m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
 463             return true;
 464         } else {
 465             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 466             return false;
 467         }
 468     }
 469
 470     bool show_helper_ise_list (void) {
 471         int    cmd;
 472         m_trans.put_command (ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST);
 473         m_trans.write_to_socket (m_socket_imclient2panel);
 474         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 475             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 476             return false;
 477         }
 478
 479         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 480             m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
 481             return true;
 482         } else {
 483             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 484             return false;
 485         }
 486     }
 487
 488     bool show_helper_ise_selector (void) {
 489         int    cmd;
 490         m_trans.put_command (ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR);
 491         m_trans.write_to_socket (m_socket_imclient2panel);
 492         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 493             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 494             return false;
 495         }
 496
 497         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 498             m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
 499             return true;
 500         } else {
 501             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 502             return false;
 503         }
 504     }
 505
 506     bool is_helper_ise_enabled (const char* appid, int &enabled)
 507     {
 508         int    cmd;
 509         uint32 tmp_enabled;
 510
 511         m_trans.put_command (ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED);
 512         m_trans.put_data (String (appid));
 513         m_trans.write_to_socket (m_socket_imclient2panel);
 514         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 515             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 516             return false;
 517         }
 518
 519         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 520                 m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK &&
 521                 m_trans.get_data (tmp_enabled)) {
 522             enabled = static_cast<int>(tmp_enabled);
 523             return true;
 524         } else {
 525             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 526             return false;
 527         }
 528     }
 529
 530     bool get_recent_ime_geometry (int *x, int *y, int *w, int *h, int angle)
 531     {
 532         int    cmd;
 533         uint32 tmp_x, tmp_y, tmp_w, tmp_h;
 534
 535         m_trans.put_command (ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY);
 536         m_trans.put_data (angle);
 537         m_trans.write_to_socket (m_socket_imclient2panel);
 538         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 539             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 540             return false;
 541         }
 542
 543         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 544                 m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK &&
 545                 m_trans.get_data (tmp_x) && m_trans.get_data (tmp_y) &&
 546                 m_trans.get_data (tmp_w) && m_trans.get_data (tmp_h)) {
 547             if (x)
 548                 *x = (int)tmp_x;
 549
 550             if (y)
 551                 *y = (int)tmp_y;
 552
 553             if (w)
 554                 *w = (int)tmp_w;
 555
 556             if (h)
 557                 *h = (int)tmp_h;
 558
 559             if ((int)tmp_w == -1 && (int)tmp_h == -1)
 560                 return false;
 561
 562             return true;
 563         } else {
 564             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 565             return false;
 566         }
 567     }
 568
 569     bool hide_helper_ise (void) {
 570         int cmd;
 571         m_trans.put_command (ISM_TRANS_CMD_HIDE_ISE_PANEL);
 572         m_trans.write_to_socket (m_socket_imclient2panel);
 573         if (!m_trans.read_from_socket (m_socket_imclient2panel, m_socket_timeout)) {
 574             std::cerr << __func__ << " read_from_socket() may be timeout \n";
 575             return false;
 576         }
 577
 578         if (m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
 579             m_trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
 580             return true;
 581         } else {
 582             std::cerr << __func__ << " get_command() or get_data() may fail!!!\n";
 583             return false;
 584         }
 585     }
 586 };
 587
 588 IMControlClient::IMControlClient ()
 589         : m_impl (new IMControlClientImpl ())
 590 {
 591 }
 592
 593 IMControlClient::~IMControlClient ()
 594 {
 595     delete m_impl;
 596 }
 597
 598 int
 599 IMControlClient::open_connection (void)
 600 {
 601     return m_impl->open_connection ();
 602 }
 603
 604 void
 605 IMControlClient::close_connection (void)
 606 {
 607     m_impl->close_connection ();
 608 }
 609
 610 bool IMControlClient::is_connected (void) const
 611 {
 612     return m_impl->is_connected ();
 613 }
 614
 615 int IMControlClient::get_panel2imclient_connection_number (void) const
 616 {
 617     return m_impl->get_panel2imclient_connection_number ();
 618 }
 619
 620 bool
 621 IMControlClient::prepare (void)
 622 {
 623     return m_impl->prepare ();
 624 }
 625
 626 bool
 627 IMControlClient::send (void)
 628 {
 629     return m_impl->send ();
 630 }
 631
 632 bool IMControlClient::set_active_ise_by_uuid (const char* uuid)
 633 {
 634     return m_impl->set_active_ise_by_uuid (uuid);
 635 }
 636
 637 bool IMControlClient::set_initial_ise_by_uuid (const char* uuid)
 638 {
 639     return m_impl->set_initial_ise_by_uuid (uuid);
 640 }
 641
 642 bool IMControlClient::get_active_ise (String &uuid)
 643 {
 644     return m_impl->get_active_ise (uuid);
 645 }
 646
 647 bool IMControlClient::get_ise_list (int* count, char*** iselist)
 648 {
 649     return m_impl->get_ise_list (count, iselist);
 650 }
 651
 652 bool IMControlClient::get_ise_info (const char* uuid, String &name, String &language, int &type, int &option, String &module_name)
 653 {
 654     return m_impl->get_ise_info (uuid, name, language, type, option, module_name);
 655 }
 656
 657 bool IMControlClient::reset_ise_option (void)
 658 {
 659     return m_impl->reset_ise_option ();
 660 }
 661
 662 void IMControlClient::set_active_ise_to_default (void)
 663 {
 664     m_impl->set_active_ise_to_default ();
 665 }
 666
 667 void IMControlClient::show_ise_selector (void)
 668 {
 669     m_impl->show_ise_selector ();
 670 }
 671
 672 void IMControlClient::show_ise_option_window (void)
 673 {
 674     m_impl->show_ise_option_window ();
 675 }
 676
 677 void IMControlClient::resume_ise_option_window (void)
 678 {
 679     m_impl->resume_ise_option_window ();
 680 }
 681
 682 bool IMControlClient::get_all_helper_ise_info (HELPER_ISE_INFO &info)
 683 {
 684     return m_impl->get_all_helper_ise_info (info);
 685 }
 686
 687 bool IMControlClient::set_enable_helper_ise_info (const char *appid, bool is_enabled)
 688 {
 689     return m_impl->set_enable_helper_ise_info (appid, is_enabled);
 690 }
 691
 692 bool IMControlClient::show_helper_ise_list (void)
 693 {
 694     return m_impl->show_helper_ise_list ();
 695 }
 696
 697 bool IMControlClient::show_helper_ise_selector (void)
 698 {
 699     return m_impl->show_helper_ise_selector ();
 700 }
 701
 702 bool IMControlClient::is_helper_ise_enabled (const char* appid, int &enabled)
 703 {
 704     return m_impl->is_helper_ise_enabled (appid, enabled);
 705 }
 706
 707 bool IMControlClient::get_recent_ime_geometry (int *x, int *y, int *w, int *h, int angle)
 708 {
 709     return m_impl->get_recent_ime_geometry (x, y, w, h, angle);
 710 }
 711
 712 bool IMControlClient::hide_helper_ise (void)
 713 {
 714     return m_impl->hide_helper_ise ();
 715 }
 716 };
 717
 718 /*
 719 vi:ts=4:nowrap:ai:expandtab
 720 */