src/sclconnection.cpp

   1 /*
   2  * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include "sclconnection.h"
  19
  20 #include "sclconnection-isf.h"
  21
  22 using namespace scl;
  23
  24 CSCLConnection::CSCLConnection()
  25 {
  26     m_backend_identifier = "undefined";
  27     m_impl = NULL;
  28 }
  29
  30 CSCLConnection::~CSCLConnection()
  31 {
  32 }
  33
  34 std::string CSCLConnection::get_backend_indentifier()
  35 {
  36     return m_backend_identifier;
  37 }
  38
  39 sclboolean CSCLConnection::init()
  40 {
  41     sclboolean ret = FALSE;
  42     if (m_impl == NULL) {
  43         /* There could be other backend implementations.. */
  44         m_impl = new CSCLConnectionISF;
  45     }
  46     if (m_impl) {
  47         ret = m_impl->init();
  48     }
  49     return ret;
  50 }
  51
  52 void CSCLConnection::fini()
  53 {
  54     if (m_impl) {
  55         m_impl->fini();
  56         delete m_impl;
  57         m_impl = NULL;
  58     }
  59 }
  60
  61 void CSCLConnection::open_connection(const sclchar *display)
  62 {
  63     if (m_impl) {
  64         m_impl->open_connection(display);
  65     }
  66 }
  67
  68 void CSCLConnection::close_connection()
  69 {
  70     if (m_impl) {
  71         m_impl->close_connection();
  72     }
  73 }
  74
  75 void CSCLConnection::config_reload()
  76 {
  77     if (m_impl) {
  78         m_impl->config_reload();
  79     }
  80 }
  81
  82 sclboolean CSCLConnection::config_read_int(const sclchar *name, sclint &value)
  83 {
  84     sclboolean ret = FALSE;
  85     if (m_impl) {
  86         ret = m_impl->config_read_int(name, value);
  87     }
  88     return ret;
  89 }
  90
  91 sclboolean CSCLConnection::config_read_string(const sclchar *name, std::string &value)
  92 {
  93     sclboolean ret = FALSE;
  94     if (m_impl) {
  95         ret = m_impl->config_read_string(name, value);
  96     }
  97     return ret;
  98 }
  99
 100 sclboolean CSCLConnection::config_write_int(const sclchar *name, sclint value)
 101 {
 102     sclboolean ret = FALSE;
 103     if (m_impl) {
 104         ret = m_impl->config_write_int(name, value);
 105     }
 106     return ret;
 107 }
 108
 109 sclboolean CSCLConnection::config_write_string(const sclchar *name, const std::string value)
 110 {
 111     sclboolean ret = FALSE;
 112     if (m_impl) {
 113         ret = m_impl->config_write_string(name, value);
 114     }
 115     return ret;
 116 }
 117
 118 sclboolean CSCLConnection::config_erase(const sclchar *name)
 119 {
 120     sclboolean ret = FALSE;
 121     if (m_impl) {
 122         ret = m_impl->config_erase(name);
 123     }
 124     return ret;
 125 }
 126
 127 void CSCLConnection::send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value)
 128 {
 129     if (m_impl) {
 130         m_impl->send_imengine_event(ic, ic_uuid, command, value);
 131     }
 132 }
 133
 134 void CSCLConnection::reset_keyboard_ise()
 135 {
 136     if (m_impl) {
 137         m_impl->reset_keyboard_ise();
 138     }
 139 }
 140
 141 void CSCLConnection::send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
 142 {
 143     if (m_impl) {
 144         m_impl->send_key_event(ic, ic_uuid, keycode, keymask);
 145     }
 146 }
 147
 148 void CSCLConnection::forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
 149 {
 150     if (m_impl) {
 151         m_impl->forward_key_event(ic, ic_uuid, keycode, keymask);
 152     }
 153 }
 154
 155 void CSCLConnection::commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
 156 {
 157     if (m_impl) {
 158         m_impl->commit_string(ic, ic_uuid, str);
 159     }
 160 }
 161
 162 void CSCLConnection::select_candidate(int index)
 163 {
 164     if (m_impl) {
 165         m_impl->select_candidate(index);
 166     }
 167 }
 168
 169 void CSCLConnection::show_preedit_string(sclint ic, const sclchar *ic_uuid)
 170 {
 171     if (m_impl) {
 172         m_impl->show_preedit_string(ic, ic_uuid);
 173     }
 174 }
 175
 176 void CSCLConnection::show_aux_string(void)
 177 {
 178     if (m_impl) {
 179         m_impl->show_aux_string();
 180     }
 181 }
 182
 183 void CSCLConnection::show_candidate_string(void)
 184 {
 185     if (m_impl) {
 186         m_impl->show_candidate_string();
 187     }
 188 }
 189
 190 void CSCLConnection::show_associate_string(void)
 191 {
 192     if (m_impl) {
 193         m_impl->show_associate_string();
 194     }
 195 }
 196
 197 void CSCLConnection::hide_preedit_string(sclint ic, const sclchar *ic_uuid)
 198 {
 199     if (m_impl) {
 200         m_impl->hide_preedit_string(ic, ic_uuid);
 201     }
 202 }
 203
 204 void CSCLConnection::hide_aux_string(void)
 205 {
 206     if (m_impl) {
 207         m_impl->hide_aux_string();
 208     }
 209 }
 210
 211 void CSCLConnection::hide_candidate_string(void)
 212 {
 213     if (m_impl) {
 214         m_impl->hide_candidate_string();
 215     }
 216 }
 217
 218 void CSCLConnection::hide_associate_string(void)
 219 {
 220     if (m_impl) {
 221         m_impl->hide_associate_string();
 222     }
 223 }
 224
 225 void CSCLConnection::update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
 226 {
 227     if (m_impl) {
 228         m_impl->update_preedit_string(ic, ic_uuid, str);
 229     }
 230 }
 231
 232 void CSCLConnection::update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str, const scim::AttributeList &attrs)
 233 {
 234     if (m_impl) {
 235         m_impl->update_preedit_string(ic, ic_uuid, str, attrs);
 236     }
 237 }
 238
 239 void CSCLConnection::update_aux_string(const sclchar *str)
 240 {
 241     if (m_impl) {
 242         m_impl->update_aux_string(str);
 243     }
 244 }
 245
 246 void CSCLConnection::update_input_context(sclu32 type, sclu32 value)
 247 {
 248     if (m_impl) {
 249         m_impl->update_input_context(type, value);
 250     }
 251 }
 252
 253 void CSCLConnection::get_surrounding_text(const sclchar *ic_uuid, sclint maxlen_before, sclint maxlen_after) const
 254 {
 255     if (m_impl) {
 256          m_impl->get_surrounding_text(ic_uuid, maxlen_before, maxlen_after);
 257      }
 258 }
 259
 260 void CSCLConnection::delete_surrounding_text(sclint offset, sclint len) const
 261 {
 262     if (m_impl) {
 263          m_impl->delete_surrounding_text(offset, len);
 264      }
 265 }
 266
 267 void CSCLConnection::set_candidate_position(sclint left, sclint top)
 268 {
 269     if (m_impl) {
 270         m_impl->set_candidate_position(left, top);
 271     }
 272 }
 273
 274 void CSCLConnection::candidate_hide(void)
 275 {
 276     if (m_impl) {
 277         m_impl->candidate_hide();
 278     }
 279 }
 280
 281 void CSCLConnection::set_keyboard_ise_by_uuid(const sclchar *uuid)
 282 {
 283     if (m_impl) {
 284         m_impl->set_keyboard_ise_by_uuid(uuid);
 285     }
 286 }
 287
 288 void CSCLConnection::get_keyboard_ise(const sclchar *uuid)
 289 {
 290     if (m_impl) {
 291         m_impl->get_keyboard_ise(uuid);
 292     }
 293 }