--- /dev/null
+Developer:
+ Ji-hoon Lee <dalton.lee at samsung dot com>
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(libscl-core CXX)
+
+SET(SRCS
+ src/sclcoreui.cpp
+ src/sclcoreui-efl.cpp
+ src/sclcoreimpl.cpp
+ src/sclconnection.cpp
+ src/sclconnection-isf.cpp
+ src/sclcore.cpp
+)
+
+SET(PACKAGE ${PROJECT_NAME})
+SET(PKGNAME ${PACKAGE})
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+SET(LIBDIR "${PREFIX}/lib")
+
+IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+ SET(CMAKE_BUILD_TYPE "Release")
+ENDIF()
+MESSAGE(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src
+ ${CMAKE_SOURCE_DIR}/src/include
+ )
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(pkgs REQUIRED
+ elementary
+ dlog
+ isf
+ vconf
+ x11
+ libscl-common
+ )
+
+FOREACH(flag ${pkgs_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall")
+SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_CXX_FLAGS_RELEASE "-O2 -g")
+
+ADD_DEFINITIONS("-DPACKAGE=\"${PACKAGE}\"")
+ADD_DEFINITIONS("-DPACKAGE_NAME=\"${PKGNAME}\"")
+ADD_DEFINITIONS("-DLOG_TAG=\"LIBSCL_CORE\"")
+ADD_DEFINITIONS("-D__EFL__")
+
+ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS})
+
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS})
+
+set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "")
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${LIBDIR})
+
+INSTALL(FILES "${CMAKE_SOURCE_DIR}/src/sclcore.h" DESTINATION include/libscl-core)
+INSTALL(FILES "${CMAKE_SOURCE_DIR}/src/sclcoretypes.h" DESTINATION include/libscl-core)
+INSTALL(FILES "${CMAKE_SOURCE_DIR}/src/sclcorecallback.h" DESTINATION include/libscl-core)
+
+CONFIGURE_FILE(${PROJECT_NAME}.pc.in ${PROJECT_NAME}.pc @ONLY)
+INSTALL(FILES ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.pc DESTINATION lib/pkgconfig)
--- /dev/null
+2014-10-29 11:15 Ji-hoon Lee <dalton.lee@samsung.com>
+
+ Initial version.
+
--- /dev/null
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
--- /dev/null
+Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+Except as noted, this software is licensed under Apache License, Version 2.
+Please, see the LICENSE file for Apache License terms and conditions.
--- /dev/null
+libscl-core
+==============
+
+This is a library that helps developing S/W Keyboards.
+
--- /dev/null
+# Package Information for pkg-config
+
+prefix=/usr
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: libscl-core
+Description: SCL Core - A library for developing software keyboards
+Version: 1.0
+Requires: libscl-common
+Libs: -L${libdir} -lscl-core
+Cflags: -I${includedir}/libscl-core
+
--- /dev/null
+<manifest>
+ <request>
+ <domain name="_"/>
+ </request>
+</manifest>
--- /dev/null
+%define _optdir /opt
+%define _appdir %{_optdir}/apps
+
+Name: libscl-core
+Summary: A library for developing software keyboards
+Version: 0.0.1
+Release: 1
+Group: System Environment/Libraries
+License: Apache License, Version 2.0
+Source0: libscl-core-%{version}.tar.gz
+BuildRequires: gettext-tools
+BuildRequires: cmake
+BuildRequires: pkgconfig(elementary)
+BuildRequires: pkgconfig(vconf)
+BuildRequires: pkgconfig(dlog)
+BuildRequires: pkgconfig(isf)
+BuildRequires: pkgconfig(x11)
+BuildRequires: pkgconfig(libscl-common)
+
+
+%description
+A library that helps developing S/W Keyboard
+
+%package devel
+Summary: SCL-Core header file
+Group: Development/Libraries
+Requires: %{name} = %{version}-%{release}
+
+%description devel
+A devel pacakge of libscl-core library that helps developing S/W Keyboard
+
+%prep
+%setup -q
+
+
+%build
+cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix}
+make %{?jobs:-j%jobs}
+
+%install
+rm -rf %{buildroot}
+mkdir -p %{buildroot}/usr/share/license
+cp LICENSE %{buildroot}/usr/share/license/%{name}
+
+%make_install
+
+
+
+%post
+
+%postun
+
+%files
+%defattr(-,root,root,-)
+%{_libdir}/libscl-core.so
+/usr/share/license/%{name}
+
+%files devel
+%defattr(-,root,root,-)
+%{_includedir}/*
+%{_libdir}/pkgconfig/libscl-core.pc
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "sclconnection-isf.h"
+#include "sclcoreimpl.h"
+
+#include <Elementary.h>
+#include <dlog.h>
+
+using namespace scl;
+
+static scim::ConfigPointer _scim_config (0);
+
+/* Slot functions for calling appropriate callback functions */
+static void slot_exit (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_ise_hide(ic, ic_uuid.c_str());
+ callback->on_exit();
+ }
+ if (agent) {
+ agent->update_ise_exit();
+ }
+ }
+ elm_exit ();
+}
+
+static void slot_attach_input_context (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_attach_input_context(ic, ic_uuid.c_str());
+ }
+ }
+}
+
+static void slot_detach_input_context (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_detach_input_context(ic, ic_uuid.c_str());
+ }
+ }
+}
+
+static void slot_reload_config (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_reload_config(ic, ic_uuid.c_str());
+ }
+ }
+}
+
+static void slot_update_screen (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid, int screen_number) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ //callback->on_update_screen(ic, ic_uuid.c_str(), screen_number);
+ }
+ }
+}
+
+static void slot_update_spot_location (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid, int x, int y) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_update_spot_location(ic, ic_uuid.c_str(), x, y);
+ }
+ }
+}
+
+static void slot_update_cursor_position (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid, int cursor_pos) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_update_cursor_position(ic, ic_uuid.c_str(), cursor_pos);
+ }
+ }
+}
+
+static void slot_update_surrounding_text (const scim::HelperAgent *agent, int ic, const scim::String &text, int cursor) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_update_surrounding_text(ic, text.c_str(), cursor);
+ }
+ }
+}
+
+static void slot_trigger_property (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid, const scim::String &property) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ //callback->on_trigger_property(ic, ic_uuid.c_str(), property.c_str());
+ }
+ }
+}
+
+static void slot_focus_out (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_focus_out(ic, ic_uuid.c_str());
+ }
+ }
+}
+
+static void slot_focus_in (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_focus_in(ic, ic_uuid.c_str());
+ }
+ }
+}
+
+static void slot_ise_show (const scim::HelperAgent *agent, int ic, char *buf, size_t &len) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ /* Make sure the appropriate keyboard ise was selected -> is this really necessary? */
+ //impl->set_keyboard_ise_by_uuid(impl->get_keyboard_ise_uuid().c_str());
+
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ /* Check if effect is enabled */
+ Ise_Context ise_context;
+ memset(&ise_context, 0x00, sizeof(ise_context));
+
+ if (len >= sizeof(Ise_Context)) {
+ memcpy(&ise_context, buf, sizeof(ise_context));
+
+ if (ise_context.imdata_size > 0) {
+ callback->on_set_imdata(buf + sizeof(ise_context), ise_context.imdata_size);
+ }
+ } else {
+ LOGD("\n-=-= WARNING - buf %p len %d size %d \n", buf, len, sizeof(ise_context));
+ }
+ callback->on_ise_show(ic, impl->get_screen_rotation_degree(), ise_context);
+ }
+ }
+}
+
+static void slot_ise_hide (const scim::HelperAgent *agent, int ic, const scim::String &ic_uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_ise_hide(ic, ic_uuid.c_str());
+ }
+ }
+}
+
+static void slot_get_geometry (const scim::HelperAgent *agent, struct scim::rectinfo &info) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_get_geometry(&(info.pos_x), &(info.pos_y), &(info.width), &(info.height));
+ }
+ }
+}
+
+static void slot_set_mode (const scim::HelperAgent *agent, scim::uint32 &mode) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_mode(mode);
+ }
+ }
+}
+
+static void slot_set_language (const scim::HelperAgent *agent, scim::uint32 &language) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_language(language);
+ }
+ }
+}
+
+static void slot_set_imdata (const scim::HelperAgent *agent, char *buf, size_t &len) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_imdata(buf, len);
+ }
+ }
+}
+
+static void slot_get_imdata (const scim::HelperAgent *, char **buf, size_t &len) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_get_imdata(buf, &len);
+ }
+ }
+}
+
+static void slot_get_language_locale (const scim::HelperAgent *, int ic, char **locale) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_get_language_locale(ic, locale);
+ }
+ }
+}
+
+static void slot_set_return_key_type (const scim::HelperAgent *agent, scim::uint32 &type) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_return_key_type(type);
+ }
+ }
+}
+
+static void slot_get_return_key_type (const scim::HelperAgent *agent, scim::uint32 &type) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_get_return_key_type(&type);
+ }
+ }
+}
+
+static void slot_set_return_key_disable (const scim::HelperAgent *agent, scim::uint32 &disabled) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_return_key_disable(disabled);
+ }
+ }
+}
+
+static void slot_get_return_key_disable (const scim::HelperAgent *agent, scim::uint32 &disabled) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_get_return_key_disable(&disabled);
+ }
+ }
+}
+
+static void slot_set_layout (const scim::HelperAgent *agent, scim::uint32 &layout) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_layout(layout);
+ }
+ }
+}
+
+static void slot_get_layout (const scim::HelperAgent *agent, scim::uint32 &layout) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_get_layout(&layout);
+ }
+ }
+}
+
+static void slot_set_caps_mode (const scim::HelperAgent *agent, scim::uint32 &mode) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_caps_mode(mode);
+ }
+ }
+}
+
+static void slot_reset_input_context (const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_reset_input_context(ic, uuid.c_str());
+ }
+ }
+}
+
+static void slot_update_candidate_geometry (const scim::HelperAgent *agent, int ic, const scim::String &uuid, const scim::rectinfo &info) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_update_candidate_geometry(ic, uuid.c_str(), info.pos_x, info.pos_y, info.width, info.height);
+ }
+ }
+}
+static void slot_update_keyboard_ise (const scim::HelperAgent *agent, int ic, const scim::String &uuid,
+ const scim::String &ise_name, const scim::String &ise_uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_update_keyboard_ise(ic, uuid.c_str(), ise_name.c_str(), ise_uuid.c_str());
+ }
+ }
+}
+
+static void slot_candidate_more_window_show (const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_candidate_more_window_show(ic, uuid.c_str());
+ }
+ }
+}
+
+static void slot_candidate_more_window_hide (const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_candidate_more_window_hide(ic, uuid.c_str());
+ }
+ }
+}
+
+static void slot_select_aux (const scim::HelperAgent *agent, int ic, const scim::String &uuid, int index) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_select_aux(ic, uuid.c_str(), index);
+ }
+ }
+}
+
+static void slot_select_candidate (const scim::HelperAgent *agent, int ic, const scim::String &uuid, int index) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_select_candidate(ic, uuid.c_str(), index);
+ }
+ }
+}
+
+static void slot_candidate_table_page_up (const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_candidate_table_page_up(ic, uuid.c_str());
+ }
+ }
+}
+
+static void slot_candidate_table_page_down (const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_candidate_table_page_down(ic, uuid.c_str());
+ }
+ }
+}
+
+static void slot_update_candidate_table_page_size (const scim::HelperAgent *, int ic, const scim::String &uuid, int page_size) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_update_candidate_table_page_size(ic, uuid.c_str(), page_size);
+ }
+ }
+}
+
+static void slot_update_lookup_table (const scim::HelperAgent *, scim::LookupTable &table) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ SclCandidateTable lookup_table;
+ lookup_table.page_size = table.get_page_size();
+ lookup_table.current_page_start = table.get_current_page_start();
+ lookup_table.cursor_pos = table.get_cursor_pos();
+ lookup_table.cursor_visible = table.is_cursor_visible();
+ lookup_table.page_size_fixed = table.is_page_size_fixed();
+ lookup_table.candidate_labels.clear();
+ for (int page_index = 0;page_index < lookup_table.page_size;page_index++) {
+ scim::WideString label = table.get_candidate_label(page_index);
+ lookup_table.candidate_labels.push_back(scim::utf8_wcstombs(label).c_str());
+ }
+
+ callback->on_update_lookup_table(lookup_table);
+
+ std::vector<scim::WideString> labels;
+ for (int loop = 0;loop < lookup_table.candidate_labels.size();loop) {
+ labels.push_back(scim::utf8_mbstowcs(lookup_table.candidate_labels.at(loop).c_str()));
+ }
+ table.set_candidate_labels(labels);
+ }
+ }
+}
+
+static void slot_select_associate (const scim::HelperAgent *agent, int ic, const scim::String &uuid, int index) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_select_associate(ic, uuid.c_str(), index);
+ }
+ }
+}
+
+static void slot_associate_table_page_up (const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_associate_table_page_up(ic, uuid.c_str());
+ }
+ }
+}
+
+static void slot_associate_table_page_down (const scim::HelperAgent *agent, int ic, const scim::String &uuid) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_associate_table_page_down(ic, uuid.c_str());
+ }
+ }
+}
+
+static void slot_update_associate_table_page_size (const scim::HelperAgent *, int ic, const scim::String &uuid, int page_size) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_update_associate_table_page_size(ic, uuid.c_str(), page_size);
+ }
+ }
+}
+
+static void slot_turn_on_log (const scim::HelperAgent *agent, scim::uint32 &on) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_turn_on_log(on);
+ }
+ }
+}
+
+/* Internal input handler function */
+Eina_Bool input_handler (void *data, Ecore_Fd_Handler *fd_handler)
+{
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ scim::HelperAgent *agent = static_cast<scim::HelperAgent*>(data);
+ if (agent) {
+ if (agent->has_pending_event()) {
+ if (!(agent->filter_event())) {
+ LOGD("helper_agent.filter_event() failed!!!\n");
+ impl->fini();
+ elm_exit();
+ }
+ } else {
+ LOGD("helper_agent.has_pending_event() failed!!!\n");
+ impl->fini();
+ elm_exit();
+ }
+ }
+ }
+
+ return ECORE_CALLBACK_RENEW;
+}
+
+CSCLConnectionISF::CSCLConnectionISF()
+{
+ m_initialized = FALSE;
+ m_fd_handler = NULL;
+
+ m_backend_identifier = "ISF";
+}
+
+CSCLConnectionISF::~CSCLConnectionISF()
+{
+}
+
+sclboolean CSCLConnectionISF::init()
+{
+ sclboolean ret = FALSE;
+
+ m_initialized = TRUE;
+
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ SclCoreAppInfo appinfo;
+ callback->on_get_app_info(&appinfo);
+ m_helper_info.uuid = scim::String(appinfo.uuid.c_str());
+ m_helper_info.name = scim::String(appinfo.name.c_str());
+ m_helper_info.option = scim::SCIM_HELPER_STAND_ALONE | scim::SCIM_HELPER_NEED_SCREEN_INFO |
+ scim::SCIM_HELPER_NEED_SPOT_LOCATION_INFO | scim::SCIM_HELPER_AUTO_RESTART;
+ }
+ }
+
+ m_helper_agent.signal_connect_exit (scim::slot (slot_exit));
+ m_helper_agent.signal_connect_attach_input_context (scim::slot (slot_attach_input_context));
+ m_helper_agent.signal_connect_detach_input_context (scim::slot (slot_detach_input_context));
+ m_helper_agent.signal_connect_reload_config (scim::slot (slot_reload_config));
+ m_helper_agent.signal_connect_update_screen (scim::slot (slot_update_screen));
+ m_helper_agent.signal_connect_update_spot_location (scim::slot (slot_update_spot_location));
+ m_helper_agent.signal_connect_update_cursor_position (scim::slot (slot_update_cursor_position));
+ m_helper_agent.signal_connect_update_surrounding_text (scim::slot (slot_update_surrounding_text));
+ m_helper_agent.signal_connect_trigger_property (scim::slot (slot_trigger_property));
+ //m_helper_agent.signal_connect_process_imengine_event (slot (slot_process_imengine_event));
+ m_helper_agent.signal_connect_focus_out (scim::slot (slot_focus_out));
+ m_helper_agent.signal_connect_focus_in (scim::slot (slot_focus_in));
+ m_helper_agent.signal_connect_ise_show (scim::slot (slot_ise_show));
+ m_helper_agent.signal_connect_ise_hide (scim::slot (slot_ise_hide));
+ m_helper_agent.signal_connect_get_geometry (scim::slot (slot_get_geometry));
+ m_helper_agent.signal_connect_set_mode (scim::slot (slot_set_mode));
+ m_helper_agent.signal_connect_set_language (scim::slot (slot_set_language));
+ m_helper_agent.signal_connect_set_imdata (scim::slot (slot_set_imdata));
+ m_helper_agent.signal_connect_get_imdata (scim::slot (slot_get_imdata));
+ m_helper_agent.signal_connect_get_language_locale (scim::slot (slot_get_language_locale));
+ m_helper_agent.signal_connect_set_return_key_type (scim::slot (slot_set_return_key_type));
+ m_helper_agent.signal_connect_get_return_key_type (scim::slot (slot_get_return_key_type));
+ m_helper_agent.signal_connect_set_return_key_disable (scim::slot (slot_set_return_key_disable));
+ m_helper_agent.signal_connect_get_return_key_disable (scim::slot (slot_get_return_key_disable));
+ m_helper_agent.signal_connect_get_layout (scim::slot (slot_get_layout));
+ m_helper_agent.signal_connect_set_layout (scim::slot (slot_set_layout));
+ m_helper_agent.signal_connect_set_caps_mode (scim::slot (slot_set_caps_mode));
+ m_helper_agent.signal_connect_reset_input_context (scim::slot (slot_reset_input_context));
+ m_helper_agent.signal_connect_update_candidate_geometry (scim::slot (slot_update_candidate_geometry));
+ m_helper_agent.signal_connect_update_keyboard_ise (scim::slot (slot_update_keyboard_ise));
+ //m_helper_agent.signal_connect_update_keyboard_ise_list (slot (slot_update_keyboard_ise_list));
+ m_helper_agent.signal_connect_candidate_more_window_show (scim::slot (slot_candidate_more_window_show));
+ m_helper_agent.signal_connect_candidate_more_window_hide (scim::slot (slot_candidate_more_window_hide));
+ m_helper_agent.signal_connect_select_aux (scim::slot (slot_select_aux));
+ m_helper_agent.signal_connect_select_candidate (scim::slot (slot_select_candidate));
+ m_helper_agent.signal_connect_candidate_table_page_up (scim::slot (slot_candidate_table_page_up));
+ m_helper_agent.signal_connect_candidate_table_page_down (scim::slot (slot_candidate_table_page_down));
+ m_helper_agent.signal_connect_update_candidate_table_page_size (scim::slot (slot_update_candidate_table_page_size));
+ m_helper_agent.signal_connect_update_lookup_table (scim::slot (slot_update_lookup_table));
+ m_helper_agent.signal_connect_select_associate (scim::slot (slot_select_associate));
+ m_helper_agent.signal_connect_associate_table_page_up (scim::slot (slot_associate_table_page_up));
+ m_helper_agent.signal_connect_associate_table_page_down (scim::slot (slot_associate_table_page_down));
+ m_helper_agent.signal_connect_update_associate_table_page_size (scim::slot (slot_update_associate_table_page_size));
+ m_helper_agent.signal_connect_turn_on_log (scim::slot (slot_turn_on_log));
+
+
+ return ret;
+}
+
+void CSCLConnectionISF::fini()
+{
+ close_connection();
+ m_initialized = FALSE;
+}
+
+void CSCLConnectionISF::open_connection(const sclchar *display)
+{
+ if (m_initialized) {
+ m_helper_agent.open_connection(m_helper_info, display);
+ int fd = m_helper_agent.get_connection_number();
+
+ if (fd >= 0) {
+ Evas_Object *main_window = NULL;
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ main_window = NATIVE_WINDOW_CAST(impl->get_main_window());
+ }
+ Ecore_X_Window xwindow = elm_win_xwindow_get(main_window);
+ char xid[255];
+ snprintf(xid, 255, "%d", xwindow);
+ scim::Property prop(xid, "XID", "", "");
+ scim::PropertyList props;
+ props.push_back(prop);
+ m_helper_agent.register_properties(props);
+
+ m_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, input_handler, &m_helper_agent, NULL, NULL);
+ }
+ }
+}
+void CSCLConnectionISF::close_connection()
+{
+ if (m_initialized) {
+ if (m_fd_handler) {
+ ecore_main_fd_handler_del(m_fd_handler);
+ m_fd_handler = NULL;
+ }
+ m_helper_agent.update_ise_exit();
+ m_helper_agent.close_connection();
+ }
+}
+
+void CSCLConnectionISF::config_reload()
+{
+ if (m_initialized) {
+ m_helper_agent.reload_config();
+ }
+}
+
+sclboolean CSCLConnectionISF::config_read_int(const sclchar *name, sclint &value)
+{
+ sclboolean ret = FALSE;
+ if (m_initialized && _scim_config) {
+ value = _scim_config->read(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLConnectionISF::config_read_string(const sclchar *name, std::string &value)
+{
+ sclboolean ret = FALSE;
+ if (m_initialized && _scim_config) {
+ value = _scim_config->read(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLConnectionISF::config_write_int(const sclchar *name, sclint value)
+{
+ sclboolean ret = FALSE;
+ if (m_initialized && _scim_config) {
+ _scim_config->write(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLConnectionISF::config_write_string(const sclchar *name, const std::string value)
+{
+ sclboolean ret = FALSE;
+ if (m_initialized && _scim_config) {
+ _scim_config->write(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLConnectionISF::config_erase(const sclchar *name)
+{
+ sclboolean ret = FALSE;
+ if (m_initialized && _scim_config) {
+ _scim_config->erase(name);
+ }
+ return ret;
+}
+
+void CSCLConnectionISF::send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value)
+{
+ if (m_initialized) {
+ scim::String uuid;
+ if (ic_uuid) {
+ uuid = scim::String(ic_uuid);
+ }
+ scim::Transaction trans;
+ trans.put_command(command);
+ trans.put_data (value);
+ m_helper_agent.send_imengine_event(ic, uuid, trans);
+ }
+}
+
+void CSCLConnectionISF::reset_keyboard_ise()
+{
+ if (m_initialized) {
+ m_helper_agent.reset_keyboard_ise();
+ }
+}
+
+void CSCLConnectionISF::send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
+{
+ if (m_initialized) {
+ scim::String uuid;
+ if (ic_uuid) {
+ uuid = scim::String(ic_uuid);
+ }
+ scim::KeyEvent event;
+ event.code = keycode;
+ event.mask = keymask;
+ m_helper_agent.send_key_event(ic, uuid, event);
+ }
+}
+
+void CSCLConnectionISF::forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
+{
+ if (m_initialized) {
+ scim::String uuid;
+ if (ic_uuid) {
+ uuid = scim::String(ic_uuid);
+ }
+ scim::KeyEvent event;
+ event.code = keycode;
+ event.mask = keymask;
+ m_helper_agent.forward_key_event(ic, uuid, event);
+ }
+}
+
+void CSCLConnectionISF::commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
+{
+ if (m_initialized) {
+ scim::String uuid;
+ if (ic_uuid) {
+ uuid = scim::String(ic_uuid);
+ }
+ m_helper_agent.commit_string(ic, uuid, scim::utf8_mbstowcs(str));
+ }
+}
+
+void CSCLConnectionISF::select_candidate(int index)
+{
+ if (m_initialized) {
+ m_helper_agent.select_candidate(index);
+ }
+}
+
+void CSCLConnectionISF::show_preedit_string(sclint ic, const sclchar *ic_uuid)
+{
+ if (m_initialized) {
+ scim::String uuid;
+ if (ic_uuid) {
+ uuid = scim::String(ic_uuid);
+ }
+ m_helper_agent.show_preedit_string(ic, uuid);
+ }
+}
+
+void CSCLConnectionISF::show_aux_string(void)
+{
+ if (m_initialized) {
+ m_helper_agent.show_aux_string();
+ }
+}
+
+void CSCLConnectionISF::show_candidate_string(void)
+{
+ if (m_initialized) {
+ m_helper_agent.show_candidate_string();
+ }
+}
+
+void CSCLConnectionISF::show_associate_string(void)
+{
+ if (m_initialized) {
+ m_helper_agent.show_associate_string();
+ }
+}
+
+void CSCLConnectionISF::hide_preedit_string(sclint ic, const sclchar *ic_uuid)
+{
+ if (m_initialized) {
+ scim::String uuid;
+ if (ic_uuid) {
+ uuid = scim::String(ic_uuid);
+ }
+ m_helper_agent.hide_preedit_string(ic, uuid);
+ }
+}
+
+void CSCLConnectionISF::hide_aux_string(void)
+{
+ if (m_initialized) {
+ m_helper_agent.hide_aux_string();
+ }
+}
+
+void CSCLConnectionISF::hide_candidate_string(void)
+{
+ if (m_initialized) {
+ m_helper_agent.hide_candidate_string();
+ }
+}
+
+void CSCLConnectionISF::hide_associate_string(void)
+{
+ if (m_initialized) {
+ m_helper_agent.hide_associate_string();
+ }
+}
+
+void CSCLConnectionISF::update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
+{
+ if (m_initialized) {
+ scim::AttributeList list;
+ scim::String uuid;
+ if (ic_uuid) {
+ uuid = scim::String(ic_uuid);
+ }
+ m_helper_agent.update_preedit_string(ic, uuid, scim::utf8_mbstowcs(str), list);
+
+ if (str && strlen(str) > 0) {
+ show_preedit_string(ic, ic_uuid);
+ } else {
+ hide_preedit_string(ic, ic_uuid);
+ }
+ }
+}
+
+void CSCLConnectionISF::update_aux_string(const sclchar *str)
+{
+ if (m_initialized) {
+ scim::AttributeList list;
+ m_helper_agent.update_aux_string(scim::String(str), list);
+ }
+}
+
+void CSCLConnectionISF::update_input_context(sclu32 type, sclu32 value)
+{
+ if (m_initialized) {
+ m_helper_agent.update_input_context(type, value);
+ }
+}
+
+void CSCLConnectionISF::set_candidate_position(sclint left, sclint top)
+{
+ if (m_initialized) {
+ m_helper_agent.set_candidate_position(left, top);
+ }
+}
+
+void CSCLConnectionISF::candidate_hide(void)
+{
+ if (m_initialized) {
+ m_helper_agent.candidate_hide();
+ }
+}
+
+void CSCLConnectionISF::set_keyboard_ise_by_uuid(const sclchar *uuid)
+{
+ if (m_initialized) {
+ m_helper_agent.set_keyboard_ise_by_uuid(uuid);
+ }
+}
+
+void CSCLConnectionISF::get_keyboard_ise(const sclchar *uuid)
+{
+ if (m_initialized) {
+ m_helper_agent.get_keyboard_ise(uuid);
+ }
+}
+
+extern "C"
+{
+ void scim_module_init (void) {
+ }
+
+ void scim_module_exit (void) {
+ }
+
+ unsigned int scim_helper_module_number_of_helpers (void) {
+ return 1;
+ }
+
+ bool scim_helper_module_get_helper_info (unsigned int idx, scim::HelperInfo &info) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ SclCoreAppInfo appinfo;
+ callback->on_get_app_info(&appinfo);
+ info.uuid = scim::String(appinfo.uuid.c_str());
+ info.name = scim::String(appinfo.name.c_str());
+ info.option = scim::SCIM_HELPER_STAND_ALONE | scim::SCIM_HELPER_NEED_SCREEN_INFO |
+ scim::SCIM_HELPER_NEED_SPOT_LOCATION_INFO | scim::SCIM_HELPER_AUTO_RESTART;
+
+ return true;
+ }
+ }
+ return false;
+ }
+
+ scim::String scim_helper_module_get_helper_language (unsigned int idx) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ SclCoreAppInfo appinfo;
+ callback->on_get_app_info(&appinfo);
+ return scim::String(appinfo.language.c_str());
+ }
+ }
+ return scim::String("");
+ }
+
+ void scim_helper_module_run_helper (const scim::String &uuid, const scim::ConfigPointer &config, const scim::String &display) {
+ _scim_config = config;
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ impl->run(display.c_str());
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __SCL_CONNECTION_ISF_H__
+#define __SCL_CONNECTION_ISF_H__
+
+#define Uses_SCIM_UTILITY
+#define Uses_SCIM_OBJECT
+#define Uses_SCIM_POINTER
+#define Uses_SCIM_EVENT
+#define Uses_SCIM_HELPER
+#define Uses_SCIM_CONFIG_BASE
+
+#include <Ecore.h>
+#include <scim.h>
+#include <string>
+#include "sclconnection.h"
+
+//SCL_BEGIN_DECLS
+
+namespace scl
+{
+
+class CSCLConnectionISF : public CSCLConnection
+{
+public:
+ CSCLConnectionISF();
+ ~CSCLConnectionISF();
+
+ virtual sclboolean init();
+ virtual void fini();
+
+ virtual void open_connection(const sclchar *display);
+ virtual void close_connection();
+
+ void config_reload();
+ sclboolean config_read_int(const sclchar *name, sclint &value);
+ sclboolean config_read_string(const sclchar *name, std::string &value);
+ sclboolean config_write_int(const sclchar *name, sclint value);
+ sclboolean config_write_string(const sclchar *name, const std::string value);
+ sclboolean config_erase(const sclchar *name);
+
+ void send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value);
+ void reset_keyboard_ise();
+ void send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask);
+ void forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask);
+ void commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str);
+ void select_candidate(int index);
+ void show_preedit_string(sclint ic, const sclchar *ic_uuid);
+ void show_aux_string(void);
+ void show_candidate_string(void);
+ void show_associate_string(void);
+ void hide_preedit_string(sclint ic, const sclchar *ic_uuid);
+ void hide_aux_string(void);
+ void hide_candidate_string(void);
+ void hide_associate_string(void);
+ void update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str);
+ void update_aux_string(const sclchar *str);
+ void update_input_context(sclu32 type, sclu32 value);
+ void set_candidate_position(sclint left, sclint top);
+ void candidate_hide(void);
+ void set_keyboard_ise_by_uuid(const sclchar *uuid);
+ void get_keyboard_ise(const sclchar *uuid);
+
+private:
+ sclboolean m_initialized;
+
+ scim::HelperInfo m_helper_info;
+ scim::HelperAgent m_helper_agent;
+
+ Ecore_Fd_Handler *m_fd_handler;
+};
+
+}
+
+//SCL_END_DECLS
+
+#endif //__SCL_CONNECTION_ISF_H__
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "sclconnection.h"
+
+#include "sclconnection-isf.h"
+
+using namespace scl;
+
+CSCLConnection::CSCLConnection()
+{
+ m_backend_identifier = "undefined";
+ m_impl = NULL;
+}
+
+CSCLConnection::~CSCLConnection()
+{
+}
+
+std::string CSCLConnection::get_backend_indentifier()
+{
+ return m_backend_identifier;
+}
+
+sclboolean CSCLConnection::init()
+{
+ sclboolean ret = FALSE;
+ if (m_impl == NULL) {
+ /* There could be other backend implementations.. */
+ m_impl = new CSCLConnectionISF;
+ }
+ if (m_impl) {
+ ret = m_impl->init();
+ }
+ return ret;
+}
+
+void CSCLConnection::fini()
+{
+ if (m_impl) {
+ m_impl->fini();
+ delete m_impl;
+ m_impl = NULL;
+ }
+}
+
+void CSCLConnection::open_connection(const sclchar *display)
+{
+ if (m_impl) {
+ m_impl->open_connection(display);
+ }
+}
+
+void CSCLConnection::close_connection()
+{
+ if (m_impl) {
+ m_impl->close_connection();
+ }
+}
+
+void CSCLConnection::config_reload()
+{
+ if (m_impl) {
+ m_impl->config_reload();
+ }
+}
+
+sclboolean CSCLConnection::config_read_int(const sclchar *name, sclint &value)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_read_int(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLConnection::config_read_string(const sclchar *name, std::string &value)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_read_string(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLConnection::config_write_int(const sclchar *name, sclint value)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_write_int(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLConnection::config_write_string(const sclchar *name, const std::string value)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_write_string(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLConnection::config_erase(const sclchar *name)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_erase(name);
+ }
+ return ret;
+}
+
+void CSCLConnection::send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value)
+{
+ if (m_impl) {
+ m_impl->send_imengine_event(ic, ic_uuid, command, value);
+ }
+}
+
+void CSCLConnection::reset_keyboard_ise()
+{
+ if (m_impl) {
+ m_impl->reset_keyboard_ise();
+ }
+}
+
+void CSCLConnection::send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
+{
+ if (m_impl) {
+ m_impl->send_key_event(ic, ic_uuid, keycode, keymask);
+ }
+}
+
+void CSCLConnection::forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
+{
+ if (m_impl) {
+ m_impl->forward_key_event(ic, ic_uuid, keycode, keymask);
+ }
+}
+
+void CSCLConnection::commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
+{
+ if (m_impl) {
+ m_impl->commit_string(ic, ic_uuid, str);
+ }
+}
+
+void CSCLConnection::select_candidate(int index)
+{
+ if (m_impl) {
+ m_impl->select_candidate(index);
+ }
+}
+
+void CSCLConnection::show_preedit_string(sclint ic, const sclchar *ic_uuid)
+{
+ if (m_impl) {
+ m_impl->show_preedit_string(ic, ic_uuid);
+ }
+}
+
+void CSCLConnection::show_aux_string(void)
+{
+ if (m_impl) {
+ m_impl->show_aux_string();
+ }
+}
+
+void CSCLConnection::show_candidate_string(void)
+{
+ if (m_impl) {
+ m_impl->show_candidate_string();
+ }
+}
+
+void CSCLConnection::show_associate_string(void)
+{
+ if (m_impl) {
+ m_impl->show_associate_string();
+ }
+}
+
+void CSCLConnection::hide_preedit_string(sclint ic, const sclchar *ic_uuid)
+{
+ if (m_impl) {
+ m_impl->hide_preedit_string(ic, ic_uuid);
+ }
+}
+
+void CSCLConnection::hide_aux_string(void)
+{
+ if (m_impl) {
+ m_impl->hide_aux_string();
+ }
+}
+
+void CSCLConnection::hide_candidate_string(void)
+{
+ if (m_impl) {
+ m_impl->hide_candidate_string();
+ }
+}
+
+void CSCLConnection::hide_associate_string(void)
+{
+ if (m_impl) {
+ m_impl->hide_associate_string();
+ }
+}
+
+void CSCLConnection::update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
+{
+ if (m_impl) {
+ m_impl->update_preedit_string(ic, ic_uuid, str);
+ }
+}
+
+void CSCLConnection::update_aux_string(const sclchar *str)
+{
+ if (m_impl) {
+ m_impl->update_aux_string(str);
+ }
+}
+
+void CSCLConnection::update_input_context(sclu32 type, sclu32 value)
+{
+ if (m_impl) {
+ m_impl->update_input_context(type, value);
+ }
+}
+
+void CSCLConnection::set_candidate_position(sclint left, sclint top)
+{
+ if (m_impl) {
+ m_impl->set_candidate_position(left, top);
+ }
+}
+
+void CSCLConnection::candidate_hide(void)
+{
+ if (m_impl) {
+ m_impl->candidate_hide();
+ }
+}
+
+void CSCLConnection::set_keyboard_ise_by_uuid(const sclchar *uuid)
+{
+ if (m_impl) {
+ m_impl->set_keyboard_ise_by_uuid(uuid);
+ }
+}
+
+void CSCLConnection::get_keyboard_ise(const sclchar *uuid)
+{
+ if (m_impl) {
+ m_impl->get_keyboard_ise(uuid);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __SCL_CONNECTION_H__
+#define __SCL_CONNECTION_H__
+
+#include <string>
+#include "scltypes.h"
+//SCL_BEGIN_DECLS
+
+namespace scl
+{
+/**
+ * @brief The base class to work as a soft-based keyboard
+ *
+ * This class implements all functions for working as a soft-based keyboard
+ * In side of ISE developer, they can modify it by their requirements.
+ */
+class CSCLConnection
+{
+public:
+ CSCLConnection();
+ ~CSCLConnection();
+
+ std::string get_backend_indentifier();
+
+ virtual sclboolean init();
+ virtual void fini();
+
+ virtual void open_connection(const sclchar *display);
+ virtual void close_connection();
+
+ virtual void config_reload();
+ virtual sclboolean config_read_int(const sclchar *name, sclint &value);
+ virtual sclboolean config_read_string(const sclchar *name, std::string &value);
+ virtual sclboolean config_write_int(const sclchar *name, sclint value);
+ virtual sclboolean config_write_string(const sclchar *name, const std::string value);
+ virtual sclboolean config_erase(const sclchar *name);
+
+ virtual void send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value);
+ virtual void reset_keyboard_ise();
+ virtual void send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask);
+ virtual void forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask);
+ virtual void commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str);
+ virtual void select_candidate(int index);
+ virtual void show_preedit_string(sclint ic, const sclchar *ic_uuid);
+ virtual void show_aux_string(void);
+ virtual void show_candidate_string(void);
+ virtual void show_associate_string(void);
+ virtual void hide_preedit_string(sclint ic, const sclchar *ic_uuid);
+ virtual void hide_aux_string(void);
+ virtual void hide_candidate_string(void);
+ virtual void hide_associate_string(void);
+ virtual void update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str);
+ virtual void update_aux_string(const sclchar *str);
+ virtual void update_input_context(sclu32 type, sclu32 value);
+ virtual void set_candidate_position(sclint left, sclint top);
+ virtual void candidate_hide(void);
+ virtual void set_keyboard_ise_by_uuid(const sclchar *uuid);
+ virtual void get_keyboard_ise(const sclchar *uuid);
+
+protected:
+ std::string m_backend_identifier;
+
+private:
+ CSCLConnection *m_impl;
+};
+
+}
+
+//SCL_END_DECLS
+
+#endif //__SCL_CONNECTION_H__
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "sclcore.h"
+#include "sclcoreimpl.h"
+
+using namespace scl;
+
+CSCLCore::CSCLCore(ISCLCoreEventCallback *callback)
+{
+ m_impl = CSCLCoreImpl::get_instance();
+
+ if (m_impl) {
+ m_impl->set_core_event_callback(callback);
+ }
+}
+
+CSCLCore::~CSCLCore()
+{
+ m_impl = NULL;
+}
+
+void CSCLCore::config_reload()
+{
+ if (m_impl) {
+ m_impl->config_reload();
+ }
+}
+
+sclboolean CSCLCore::config_read_int(const sclchar *name, sclint &value)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_read_int(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLCore::config_read_string(const sclchar *name, std::string &value)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_read_string(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLCore::config_write_int(const sclchar *name, sclint value)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_write_int(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLCore::config_write_string(const sclchar *name, const std::string value)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_write_string(name, value);
+ }
+ return ret;
+}
+
+sclboolean CSCLCore::config_erase(const sclchar *name)
+{
+ sclboolean ret = FALSE;
+ if (m_impl) {
+ ret = m_impl->config_erase(name);
+ }
+ return ret;
+}
+
+void CSCLCore::send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value)
+{
+ if (m_impl) {
+ m_impl->send_imengine_event(ic, ic_uuid, command, value);
+ }
+}
+
+void CSCLCore::reset_keyboard_ise()
+{
+ if (m_impl) {
+ m_impl->reset_keyboard_ise();
+ }
+}
+
+void CSCLCore::send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
+{
+ if (m_impl) {
+ m_impl->send_key_event(ic, ic_uuid, keycode, keymask);
+ }
+}
+
+void CSCLCore::forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
+{
+ if (m_impl) {
+ m_impl->forward_key_event(ic, ic_uuid, keycode, keymask);
+ }
+}
+
+void CSCLCore::commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
+{
+ if (m_impl) {
+ m_impl->commit_string(ic, ic_uuid, str);
+ }
+}
+
+void CSCLCore::select_candidate(int index)
+{
+ if (m_impl) {
+ m_impl->select_candidate(index);
+ }
+}
+
+void CSCLCore::show_preedit_string(sclint ic, const sclchar *ic_uuid)
+{
+ if (m_impl) {
+ m_impl->show_preedit_string(ic, ic_uuid);
+ }
+}
+
+void CSCLCore::show_aux_string(void)
+{
+ if (m_impl) {
+ m_impl->show_aux_string();
+ }
+}
+
+void CSCLCore::show_candidate_string(void)
+{
+ if (m_impl) {
+ m_impl->show_candidate_string();
+ }
+}
+
+void CSCLCore::show_associate_string(void)
+{
+ if (m_impl) {
+ m_impl->show_associate_string();
+ }
+}
+
+void CSCLCore::hide_preedit_string(sclint ic, const sclchar *ic_uuid)
+{
+ if (m_impl) {
+ m_impl->hide_preedit_string(ic, ic_uuid);
+ }
+}
+
+void CSCLCore::hide_aux_string(void)
+{
+ if (m_impl) {
+ m_impl->hide_aux_string();
+ }
+}
+
+void CSCLCore::hide_candidate_string(void)
+{
+ if (m_impl) {
+ m_impl->hide_candidate_string();
+ }
+}
+
+void CSCLCore::hide_associate_string(void)
+{
+ if (m_impl) {
+ m_impl->hide_associate_string();
+ }
+}
+
+void CSCLCore::update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
+{
+ if (m_impl) {
+ m_impl->update_preedit_string(ic, ic_uuid, str);
+ }
+}
+
+void CSCLCore::update_aux_string(const sclchar *str)
+{
+ if (m_impl) {
+ m_impl->update_aux_string(str);
+ }
+}
+
+void CSCLCore::update_input_context(sclu32 type, sclu32 value)
+{
+ if (m_impl) {
+ m_impl->update_input_context(type, value);
+ }
+}
+
+void CSCLCore::set_candidate_position(sclint left, sclint top)
+{
+ if (m_impl) {
+ m_impl->set_candidate_position(left, top);
+ }
+}
+
+void CSCLCore::candidate_hide(void)
+{
+ if (m_impl) {
+ m_impl->candidate_hide();
+ }
+}
+
+void CSCLCore::set_keyboard_ise_by_uuid(const sclchar *uuid)
+{
+ if (m_impl) {
+ m_impl->set_keyboard_ise_by_uuid(uuid);
+ }
+}
+
+void CSCLCore::get_keyboard_ise(const sclchar *uuid)
+{
+ if (m_impl) {
+ m_impl->get_keyboard_ise(uuid);
+ }
+}
+
+sclwindow CSCLCore::get_main_window()
+{
+ sclwindow ret = SCLWINDOW_INVALID;
+ if (m_impl) {
+ ret = m_impl->get_main_window();
+ }
+ return ret;
+}
+
+void CSCLCore::set_keyboard_size_hints(SclSize portrait, SclSize landscape)
+{
+ if (m_impl) {
+ m_impl->set_keyboard_size_hints(portrait, landscape);
+ }
+}
+
+sclwindow CSCLCore::create_option_window()
+{
+ sclwindow ret = SCLWINDOW_INVALID;
+ if (m_impl) {
+ ret = m_impl->create_option_window();
+ }
+ return ret;
+}
+
+void CSCLCore::destroy_option_window(sclwindow window)
+{
+ if (m_impl) {
+ m_impl->destroy_option_window(window);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __SCL_CORE_H__
+#define __SCL_CORE_H__
+
+//SCL_BEGIN_DECLS
+
+#include <string>
+
+#include <sclcommon.h>
+#include "sclcoretypes.h"
+#include "sclcorecallback.h"
+
+namespace scl
+{
+
+/* To use pimpl idiom */
+class CSCLCoreImpl;
+
+/**
+ * @brief The base class that provides features for a soft-keyboard
+ *
+ * This class implements all functions for working as a soft-based keyboard
+ */
+class CSCLCore
+{
+public:
+ CSCLCore(ISCLCoreEventCallback *callback);
+ ~CSCLCore();
+
+ /**
+ * @brief Request ISF to reload all configuration.
+ */
+ void config_reload();
+
+ /**
+ * @brief Request ISF to read a integer value with given key name.
+ */
+ sclboolean config_read_int(const sclchar *name, sclint &value);
+
+ /**
+ * @brief Request ISF to read a string value with given key name.
+ */
+ sclboolean config_read_string(const sclchar *name, std::string &value);
+
+ /**
+ * @brief Request ISF to write a integer value with given key name.
+ */
+ sclboolean config_write_int(const sclchar *name, sclint value);
+
+ /**
+ * @brief Request ISF to write a string value with given key name.
+ */
+ sclboolean config_write_string(const sclchar *name, const std::string value);
+
+ /**
+ * @brief Request ISF to erase stored value with given key name.
+ */
+ sclboolean config_erase(const sclchar *name);
+
+ /**
+ * @brief Send an Event to IMEngine
+ *
+ * @param[in] ic The handle of the IMEngineInstance to receive the event.
+ * -1 means the currently focused IMEngineInstance.
+ * @param[in] ic_uuid The UUID of the IMEngineInstance. NULL means don't match.
+ * @param[in] command The command to be sent.
+ * @param[in] value The value corresponding to the command.
+ */
+ void send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value);
+
+ /**
+ * @brief Send a reset keyboard Event to IMEngine
+ */
+ void reset_keyboard_ise();
+
+ /**
+ * @brief Send a KeyEvent to ISF
+ *
+ * @param[in] ic The handle of the IMEngineInstance to receive the event.
+ * -1 means the currently focused IMEngineInstance.
+ * @param[in] ic_uuid The UUID of the IMEngineInstance. NULL means don't match.
+ * @param[in] keycode The KeyEvent to be sent.
+ * @param[in] keymask The modifier key mask
+ */
+ void send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask);
+
+ /**
+ * @brief Forward a KeyEvent to client application directly.
+ *
+ * @param[in] ic The handle of the client Input Context to receive the event.
+ * -1 means the currently focused Input Context.
+ * @param[in] ic_uuid The UUID of the IMEngineInstance. NULL means don't match.
+ * @param[in] keycode The KeyEvent to be sent.
+ * @param[in] keymask The modifier key mask
+ */
+ void forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask);
+
+ /**
+ * @brief Commit a string to client application directly.
+ *
+ * @param[in] ic The handle of the client Input Context to receive the WideString.
+ * -1 means the currently focused Input Context.
+ * @param[in] ic_uuid The UUID of the IMEngine used by the Input Context.
+ * NULL means don't match.
+ * @param[in] str The UTF-8 string to be committed.
+ */
+ void commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str);
+
+ void select_candidate(int index);
+ /**
+ * @brief Request to show preedit string.
+ *
+ * @param[in] ic The handle of the client Input Context to receive the request.
+ * -1 means the currently focused Input Context.
+ * @param[in] ic_uuid The UUID of the IMEngine used by the Input Context.
+ * NULL means don't match.
+ */
+ void show_preedit_string(sclint ic, const sclchar *ic_uuid);
+
+ /**
+ * @brief Request to show aux string.
+ */
+ void show_aux_string(void);
+
+ /**
+ * @brief Request to show candidate string.
+ */
+ void show_candidate_string(void);
+
+ /**
+ * @brief Request to show associate string.
+ */
+ void show_associate_string(void);
+
+ /**
+ * @brief Request to hide preedit string.
+ *
+ * @param[in] ic The handle of the client Input Context to receive the request.
+ * -1 means the currently focused Input Context.
+ * @param[in] ic_uuid The UUID of the IMEngine used by the Input Context.
+ * NULL means don't match.
+ */
+ void hide_preedit_string(sclint ic, const sclchar *ic_uuid);
+
+ /**
+ * @brief Request to hide aux string.
+ */
+ void hide_aux_string(void);
+
+ /**
+ * @brief Request to hide candidate string.
+ */
+ void hide_candidate_string(void);
+
+ /**
+ * @brief Request to hide associate string.
+ */
+ void hide_associate_string(void);
+
+ /**
+ * @brief Update a new WideString for preedit.
+ *
+ * @param[in] ic The handle of the client Input Context to receive the WideString.
+ * -1 means the currently focused Input Context.
+ * @param[in] ic_uuid The UUID of the IMEngine used by the Input Context.
+ * NULL means don't match.
+ * @param[in] str The UTF-8 string to be updated.
+ * @param[in] attrs The attribute list for preedit string.
+ */
+ /*void update_preedit_string (int ic, const sclchar *ic_uuid, const sclchar *str, const AttributeList &attrs) const;*/
+ void update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str);
+
+ /**
+ * @brief Update a new string for aux.
+ *
+ * @param[in] str The string to be updated.
+ * @param[in] attrs The attribute list for aux string.
+ */
+ //void update_aux_string (const sclchar *str, const AttributeList &attrs) const;
+ void update_aux_string(const sclchar *str);
+
+ /**
+ * @brief Request to update candidate.
+ *
+ * @param[in] table The lookup table for candidate.
+ */
+ void update_candidate_string(const SclCandidateTable &table) const;
+
+ /**
+ * @brief Request to update associate.
+ *
+ * @param[in] table The lookup table for associate.
+ */
+ void update_associate_string(const SclCandidateTable &table) const;
+
+ /**
+ * @ brief When the input context of ISE is changed,
+ * ISE can call this function to notify application
+ *
+ * @param[in] type type of event.
+ * @param[in] value value of event.
+ */
+ void update_input_context(sclu32 type, sclu32 value);
+
+ /**
+ * @ brief Request to get surrounding text.
+ *
+ * @param[in] uuid The helper ISE UUID.
+ * @param[in] maxlen_before The max length of before.
+ * @param[in] maxlen_after The max length of after.
+ */
+ void get_surrounding_text(const sclchar *uuid, sclint maxlen_before, sclint maxlen_after) const;
+
+ /**
+ * @ brief Request to delete surrounding text.
+ *
+ * @param[in] offset The offset for cursor position.
+ * @param[in] len The length for delete text.
+ */
+ void delete_surrounding_text(int offset, int len) const;
+
+ /**
+ * @ brief Set candidate position in screen.
+ *
+ * @param[in] left The x position in screen.
+ * @param[in] top The y position in screen.
+ */
+ void set_candidate_position(sclint left, sclint top);
+
+ /**
+ * @ brief Request to hide candidate window.
+ */
+ void candidate_hide(void);
+
+ /**
+ * @ brief Request to get candidate window size and position.
+ *
+ * @param[in] uuid The helper ISE UUID.
+ */
+ //void get_candidate_window_geometry (const String &uuid) const;
+
+ /**
+ * @ brief Set current keyboard ISE.
+ *
+ * @param[in] uuid The keyboard ISE UUID.
+ */
+ void set_keyboard_ise_by_uuid(const sclchar *uuid);
+
+ /**
+ * @ brief Request to get current keyboard ISE information.
+ *
+ * @param[in] uuid The helper ISE UUID.
+ */
+ void get_keyboard_ise(const sclchar *uuid);
+
+ /**
+ * @ brief Request to get uuid list of all keyboard ISEs.
+ *
+ * @param[in] uuid The helper ISE UUID.
+ */
+ //void get_keyboard_ise_list (const String &uuid) const;
+
+ /**
+ * @brief This API returns the pointer to main keyboard window
+ */
+ sclwindow get_main_window();
+
+ /**
+ * @brief This API updates the keyboard window's geometry information
+ */
+ void set_keyboard_size_hints(SclSize portrait, SclSize landscape);
+
+ /**
+ * @brief Requests to create an option window
+ */
+ sclwindow create_option_window();
+
+ /**
+ * @brief Requests to destroy an option window
+ */
+ void destroy_option_window(sclwindow window);
+
+private:
+ CSCLCoreImpl *m_impl;
+};
+
+}
+
+//SCL_END_DECLS
+
+#endif //__SCL_CORE_H__
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <ise_context.h>
+#include "scltypes.h"
+#include "sclcoretypes.h"
+
+#ifndef __SCL_CORE_CALLBACK_H__
+#define __SCL_CORE_CALLBACK_H__
+
+//SCL_BEGIN_DECLS
+
+namespace scl
+{
+
+/* The SCL Core app information struct */
+typedef struct {
+ /* The name of this input method
+ Example : "Tizen keyboard" */
+ std::string name;
+ /* The uuid to identify this input method
+ Example : "12aa3425-f88d-45f4-a509-cee8dfe904e3"*/
+ std::string uuid;
+ /* The locale string that this input methods supports
+ Example : "en_US" */
+ std::string language;
+} SclCoreAppInfo;
+
+struct ISCLCoreEventCallback {
+ virtual void on_get_app_info(SclCoreAppInfo *info) {}
+
+ virtual void on_init() {}
+ virtual void on_exit() {}
+ virtual void on_attach_input_context(sclint ic, const sclchar *ic_uuid) {}
+ virtual void on_detach_input_context(sclint ic, const sclchar *ic_uuid) {}
+ virtual void on_reload_config(sclint ic, const sclchar *ic_uuid) {}
+ virtual void on_update_spot_location(sclint ic, const sclchar *ic_uuid, sclint x, sclint y) {}
+ virtual void on_update_cursor_position(sclint ic, const sclchar *ic_uuid, sclint cursor_pos) {}
+ virtual void on_update_surrounding_text(sclint ic, const sclchar *text, sclint cursor) {}
+ virtual void on_focus_out(sclint ic, const sclchar *ic_uuid) {}
+ virtual void on_focus_in(sclint ic, const sclchar *ic_uuid) {}
+ virtual void on_ise_show(sclint ic, const int degree, Ise_Context context) {}
+ virtual void on_ise_hide(sclint ic, const sclchar *ic_uuid) {}
+ virtual void on_get_geometry(sclu32 *pos_x, sclu32 *pos_y, sclu32 *width, sclu32 *height) {}
+ virtual void on_set_mode(sclu32 mode) {}
+ virtual void on_set_language(sclu32 language) {}
+ virtual void on_set_imdata(sclchar *buf, sclu32 len) {}
+ virtual void on_get_imdata(sclchar **buf, sclu32 *len) {}
+ virtual void on_get_language_locale(sclint ic, sclchar **locale) {}
+ virtual void on_set_return_key_type(sclu32 type) {}
+ virtual void on_get_return_key_type(sclu32 *type) {}
+ virtual void on_set_return_key_disable(sclu32 disabled) {}
+ virtual void on_get_return_key_disable(sclu32 *disabled) {}
+ virtual void on_set_layout(sclu32 layout) {}
+ virtual void on_get_layout(sclu32 *layout) {}
+ virtual void on_set_caps_mode(sclu32 mode) {}
+ virtual void on_reset_input_context(sclint ic, const sclchar *uuid) {}
+ virtual void on_update_candidate_geometry(sclint ic, const sclchar *uuid, sclu32 pos_x, sclu32 pos_y, sclu32 width, sclu32 height) {}
+ virtual void on_update_keyboard_ise(sclint ic, const sclchar *uuid, const sclchar *ise_name, const sclchar *ise_uuid) {}
+ virtual void on_candidate_more_window_show(sclint ic, const sclchar *uuid) {}
+ virtual void on_candidate_more_window_hide(sclint ic, const sclchar *uuid) {}
+ virtual void on_select_aux(sclint ic, const sclchar *uuid, sclint index) {}
+ virtual void on_select_candidate(sclint ic, const sclchar *uuid, sclint index) {}
+ virtual void on_candidate_table_page_up(sclint ic, const sclchar *uuid) {}
+ virtual void on_candidate_table_page_down(sclint ic, const sclchar *uuid) {}
+ virtual void on_update_lookup_table(SclCandidateTable& table) {}
+ virtual void on_update_candidate_table_page_size(sclint ic, const sclchar *uuid, sclint page_size) {}
+ virtual void on_select_associate(sclint ic, const sclchar *uuid, sclint index) {}
+ virtual void on_associate_table_page_up(sclint ic, const sclchar *uuid) {}
+ virtual void on_associate_table_page_down(sclint ic, const sclchar *uuid) {}
+ virtual void on_update_associate_table_page_size(sclint ic, const sclchar *uuid, sclint page_size) {}
+ virtual void on_turn_on_log(sclu32 on) {}
+
+ virtual void on_set_display_language(const sclchar *language) {}
+ virtual void on_set_theme_name(const sclchar *name) {}
+ virtual void on_set_rotation_degree(sclint degree) {}
+ virtual void on_set_accessibility_state(sclboolean state) {}
+
+ virtual void on_create_option_window(sclwindow window, SCLOptionWindowType type) {}
+ virtual void on_destroy_option_window(sclwindow window) {}
+};
+
+}
+
+//SCL_END_DECLS
+
+#endif //__SCL_CORE_CALLBACK_H__
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "sclcoreimpl.h"
+
+using namespace scl;
+
+CSCLCoreImpl::CSCLCoreImpl()
+{
+ m_event_callback = NULL;
+}
+
+CSCLCoreImpl::~CSCLCoreImpl()
+{
+}
+
+CSCLCoreImpl*
+CSCLCoreImpl::get_instance()
+{
+ static CSCLCoreImpl instance;
+ return &instance;
+}
+
+void CSCLCoreImpl::init(const sclchar *display)
+{
+ m_connection.init();
+ m_core_ui.init();
+
+ m_connection.open_connection(display);
+
+ if (m_event_callback) {
+ m_event_callback->on_init();
+ }
+}
+
+void CSCLCoreImpl::fini()
+{
+ if (m_event_callback) {
+ m_event_callback->on_exit();
+ }
+
+ m_connection.close_connection();
+
+ m_core_ui.fini();
+ m_connection.fini();
+}
+
+void CSCLCoreImpl::set_core_event_callback(ISCLCoreEventCallback *callback)
+{
+ m_event_callback = callback;
+}
+
+ISCLCoreEventCallback* CSCLCoreImpl::get_core_event_callback()
+{
+ ISCLCoreEventCallback* ret = m_event_callback;
+ return ret;
+}
+
+void CSCLCoreImpl::config_reload()
+{
+ m_connection.config_reload();
+}
+
+sclboolean CSCLCoreImpl::config_read_int(const sclchar *name, sclint &value)
+{
+ return m_connection.config_read_int(name, value);
+}
+
+sclboolean CSCLCoreImpl::config_read_string(const sclchar *name, std::string &value)
+{
+ return m_connection.config_read_string(name, value);
+}
+
+sclboolean CSCLCoreImpl::config_write_int(const sclchar *name, sclint value)
+{
+ return m_connection.config_write_int(name, value);
+}
+
+sclboolean CSCLCoreImpl::config_write_string(const sclchar *name, const std::string value)
+{
+ return m_connection.config_write_string(name, value);
+}
+
+sclboolean CSCLCoreImpl::config_erase(const sclchar *name)
+{
+ return m_connection.config_erase(name);
+}
+
+void CSCLCoreImpl::send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value)
+{
+ m_connection.send_imengine_event(ic, ic_uuid, command, value);
+}
+
+void CSCLCoreImpl::reset_keyboard_ise()
+{
+ m_connection.reset_keyboard_ise();
+}
+
+void CSCLCoreImpl::send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
+{
+ m_connection.send_key_event(ic, ic_uuid, keycode, keymask);
+}
+
+void CSCLCoreImpl::forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask)
+{
+ m_connection.forward_key_event(ic, ic_uuid, keycode, keymask);
+}
+
+void CSCLCoreImpl::commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
+{
+ m_connection.commit_string(ic, ic_uuid, str);
+}
+
+void CSCLCoreImpl::select_candidate(int index)
+{
+ m_connection.select_candidate(index);
+}
+
+void CSCLCoreImpl::show_preedit_string(sclint ic, const sclchar *ic_uuid)
+{
+ m_connection.show_preedit_string(ic, ic_uuid);
+}
+
+void CSCLCoreImpl::show_aux_string(void)
+{
+ m_connection.show_aux_string();
+}
+
+void CSCLCoreImpl::show_candidate_string(void)
+{
+ m_connection.show_candidate_string();
+}
+
+void CSCLCoreImpl::show_associate_string(void)
+{
+ m_connection.show_associate_string();
+}
+
+void CSCLCoreImpl::hide_preedit_string(sclint ic, const sclchar *ic_uuid)
+{
+ m_connection.hide_preedit_string(ic, ic_uuid);
+}
+
+void CSCLCoreImpl::hide_aux_string(void)
+{
+ m_connection.hide_aux_string();
+}
+
+void CSCLCoreImpl::hide_candidate_string(void)
+{
+ m_connection.hide_candidate_string();
+}
+
+void CSCLCoreImpl::hide_associate_string(void)
+{
+ m_connection.hide_associate_string();
+}
+
+void CSCLCoreImpl::update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str)
+{
+ m_connection.update_preedit_string(ic, ic_uuid, str);
+}
+
+void CSCLCoreImpl::update_aux_string(const sclchar *str)
+{
+ m_connection.update_aux_string(str);
+}
+
+void CSCLCoreImpl::update_input_context(sclu32 type, sclu32 value)
+{
+ m_connection.update_input_context(type, value);
+}
+
+void CSCLCoreImpl::set_candidate_position(sclint left, sclint top)
+{
+ m_connection.set_candidate_position(left, top);
+}
+
+void CSCLCoreImpl::candidate_hide(void)
+{
+ m_connection.candidate_hide();
+}
+
+void CSCLCoreImpl::set_keyboard_ise_by_uuid(const sclchar *uuid)
+{
+ m_connection.set_keyboard_ise_by_uuid(uuid);
+}
+
+void CSCLCoreImpl::get_keyboard_ise(const sclchar *uuid)
+{
+ m_connection.get_keyboard_ise(uuid);
+}
+
+void CSCLCoreImpl::run(const sclchar *display)
+{
+ m_core_ui.init();
+ m_connection.init();
+
+ m_core_ui.run(display);
+
+ m_connection.fini();
+ m_core_ui.fini();
+}
+
+sclwindow CSCLCoreImpl::get_main_window()
+{
+ return m_core_ui.get_main_window();
+}
+
+int CSCLCoreImpl::get_screen_rotation_degree()
+{
+ return m_core_ui.get_screen_rotation_degree();
+}
+
+void CSCLCoreImpl::set_keyboard_size_hints(SclSize portrait, SclSize landscape)
+{
+ m_core_ui.set_keyboard_size_hints(portrait, landscape);
+}
+
+sclwindow CSCLCoreImpl::create_option_window()
+{
+ return m_core_ui.create_option_window(OPTION_WINDOW_TYPE_NORMAL);
+}
+
+void CSCLCoreImpl::destroy_option_window(sclwindow window)
+{
+ m_core_ui.destroy_option_window(window);
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __SCL_CORE_IMPL_H__
+#define __SCL_CORE_IMPL_H__
+
+#include "sclcore.h"
+#include "sclcoreui.h"
+#include "sclcorecallback.h"
+#include "sclconnection.h"
+
+//SCL_BEGIN_DECLS
+
+namespace scl
+{
+
+class CSCLCoreImpl
+{
+private:
+ CSCLCoreImpl();
+
+public:
+ ~CSCLCoreImpl();
+ static CSCLCoreImpl* get_instance();
+
+ void init(const sclchar *display);
+ void fini();
+
+ void run(const sclchar *display);
+
+ void set_core_event_callback(ISCLCoreEventCallback *callback);
+ ISCLCoreEventCallback* get_core_event_callback();
+
+ void config_reload();
+ sclboolean config_read_int(const sclchar *name, sclint &value);
+ sclboolean config_read_string(const sclchar *name, std::string &value);
+ sclboolean config_write_int(const sclchar *name, sclint value);
+ sclboolean config_write_string(const sclchar *name, const std::string value);
+ sclboolean config_erase(const sclchar *name);
+
+ void send_imengine_event(sclint ic, const sclchar *ic_uuid, const sclint command, const sclu32 value);
+ void reset_keyboard_ise();
+ void send_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask);
+ void forward_key_event(sclint ic, const sclchar *ic_uuid, sclu32 keycode, sclu16 keymask);
+ void commit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str);
+ void select_candidate(int index);
+ void show_preedit_string(sclint ic, const sclchar *ic_uuid);
+ void show_aux_string(void);
+ void show_candidate_string(void);
+ void show_associate_string(void);
+ void hide_preedit_string(sclint ic, const sclchar *ic_uuid);
+ void hide_aux_string(void);
+ void hide_candidate_string(void);
+ void hide_associate_string(void);
+ /*void update_preedit_string (int ic, const sclchar *ic_uuid, const sclchar *str, const AttributeList &attrs) const;*/
+ void update_preedit_string(sclint ic, const sclchar *ic_uuid, const sclchar *str);
+ //void update_aux_string (const sclchar *str, const AttributeList &attrs) const;
+ void update_aux_string(const sclchar *str);
+ //void update_candidate_string (const LookupTable &table) const;
+ //void update_associate_string (const LookupTable &table) const;
+ void update_input_context(sclu32 type, sclu32 value);
+ //void get_surrounding_text (const String &uuid,
+ // int maxlen_before,
+ // int maxlen_after) const;
+ //void delete_surrounding_text (int offset,
+ // int len) const;
+ void set_candidate_position(sclint left, sclint top);
+ void candidate_hide(void);
+ //void get_candidate_window_geometry (const String &uuid) const;
+ void set_keyboard_ise_by_uuid(const sclchar *uuid);
+ void get_keyboard_ise(const sclchar *uuid);
+ //void get_keyboard_ise_list (const String &uuid) const;
+
+ sclwindow get_main_window();
+ int get_screen_rotation_degree();
+ void set_keyboard_size_hints(SclSize portrait, SclSize landscape);
+
+ sclwindow create_option_window();
+ void destroy_option_window(sclwindow window);
+
+private:
+ SclCoreAppInfo m_app_info;
+ ISCLCoreEventCallback *m_event_callback;
+
+ CSCLConnection m_connection;
+ CSCLCoreUI m_core_ui;
+};
+
+}
+
+//SCL_END_DECLS
+
+#endif //__SCL_CORE_IMPL_H__
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __SCL_CORE_TYPES_H__
+#define __SCL_CORE_TYPES_H__
+
+#include <string>
+#include <vector>
+
+#include "scltypes.h"
+
+namespace scl
+{
+
+typedef enum _SCLKeyMask
+{
+ KEY_MASK_NULL = 0,
+ KEY_MASK_SHIFT = (1<<0),
+ KEY_MASK_RELEASE = (1<<15),
+} SCLKeyMask;
+
+typedef enum _SCLOptionWindowType
+{
+ OPTION_WINDOW_TYPE_NORMAL,
+ OPTION_WINDOW_TYPE_SETTINGAPPLICATION,
+
+ OPTION_WINDOW_TYPE_MAX,
+} SCLOptionWindowType;
+
+typedef struct _SclCandidateTable{
+ sclint page_size;
+ sclint current_page_start;
+ sclint cursor_pos;
+ sclboolean cursor_visible;
+ sclboolean page_size_fixed;
+
+ std::vector<std::string> candidate_labels;
+} SclCandidateTable;
+
+}
+
+//SCL_END_DECLS
+
+#endif //__SCL_CORE_TYPES_H__
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "sclcoreui-efl.h"
+#include "sclcoreimpl.h"
+
+#include <Elementary.h>
+#include <dlog.h>
+
+#include <vconf.h>
+#include <vconf-keys.h>
+
+#include <glib.h>
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+
+using namespace scl;
+
+
+CSCLCoreUIEFL::CSCLCoreUIEFL()
+{
+ m_initialized = FALSE;
+
+ m_backend_identifier = "EFL";
+}
+
+CSCLCoreUIEFL::~CSCLCoreUIEFL()
+{
+}
+
+sclboolean CSCLCoreUIEFL::init()
+{
+ sclboolean ret = FALSE;
+
+ m_initialized = TRUE;
+ m_rotation_degree = -1;
+
+ for (int loop = 0;loop < OPTION_WINDOW_TYPE_MAX;loop++) {
+ m_option_window_info[OPTION_WINDOW_TYPE_NORMAL].window = SCLWINDOW_INVALID;
+ m_option_window_info[OPTION_WINDOW_TYPE_NORMAL].handler = NULL;
+ }
+
+ return ret;
+}
+
+void CSCLCoreUIEFL::fini()
+{
+ m_initialized = FALSE;
+}
+
+sclwindow CSCLCoreUIEFL::get_main_window()
+{
+ if (m_initialized) {
+ return m_main_window;
+ }
+}
+
+void CSCLCoreUIEFL::set_keyboard_size_hints(SclSize portrait, SclSize landscape)
+{
+ Evas_Object *main_window = NATIVE_WINDOW_CAST(m_main_window);
+ ecore_x_e_window_rotation_geometry_set(elm_win_xwindow_get(main_window), 0, 0, 0, portrait.width, portrait.height);
+ ecore_x_e_window_rotation_geometry_set(elm_win_xwindow_get(main_window), 90, 0, 0, landscape.height, landscape.width);
+ ecore_x_e_window_rotation_geometry_set(elm_win_xwindow_get(main_window), 180, 0, 0, portrait.width, portrait.height);
+ ecore_x_e_window_rotation_geometry_set(elm_win_xwindow_get(main_window), 270, 0, 0, landscape.height, landscape.width);
+}
+
+const char * extract_themename_from_theme_file_path(const char *filepath) {
+ static char themename[_POSIX_PATH_MAX] = {0};
+ memset(themename, 0x00, sizeof(themename));
+
+ if (filepath) {
+ /* There could be more than 1 theme filepath, separated by : */
+ char pathstr[_POSIX_PATH_MAX] = {0};
+ strncpy(pathstr, filepath, _POSIX_PATH_MAX - 1);
+ for(int loop = 0;loop < _POSIX_PATH_MAX;loop++) {
+ if (pathstr[loop] == ':') {
+ /* FIXME : Let's consider the 1st theme filepath only for now */
+ pathstr[loop] = '\0';
+ }
+ }
+
+ if (pathstr[0]) {
+ const char *filename = ecore_file_file_get(pathstr);
+ if (filename) {
+ char *stripname = ecore_file_strip_ext(filename);
+ if (stripname) {
+ strncpy(themename, stripname, _POSIX_PATH_MAX - 1);
+ free(stripname);
+ }
+ }
+ }
+ }
+
+ return themename;
+}
+
+void language_changed_cb(keynode_t *key, void* data)
+{
+ char clang[_POSIX_PATH_MAX] = {0};
+ char *vconf_str = vconf_get_str(VCONFKEY_LANGSET);
+ if (vconf_str) {
+ snprintf(clang, sizeof(clang), "%s",vconf_str);
+ free(vconf_str);
+ }
+ LOGD("current language is %s\n",clang);
+
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_display_language(clang);
+ }
+ }
+}
+
+void theme_changed_cb(keynode_t *key, void* data)
+{
+ char clang[256] = {0};
+ char *vconf_str = vconf_get_str(VCONFKEY_SETAPPL_WIDGET_THEME_STR);
+ if (vconf_str) {
+ snprintf(clang, sizeof(clang), "%s",extract_themename_from_theme_file_path(vconf_str));
+ free(vconf_str);
+ }
+ LOGD("current theme is %s\n",clang);
+
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_theme_name(clang);
+ }
+ }
+}
+
+void accessibility_changed_cb(keynode_t *key, void* data)
+{
+ int vconf_value = 0;
+ if (vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, &vconf_value) == 0) {
+ LOGD("accessbility state : %d\n", vconf_value);
+
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_set_accessibility_state(vconf_value);
+ }
+ }
+ }
+}
+
+static Eina_Bool _client_message_cb (void *data, int type, void *event)
+{
+ Ecore_X_Event_Client_Message *ev = (Ecore_X_Event_Client_Message *)event;
+
+ ISCLCoreEventCallback *callback = NULL;
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ Evas_Object *main_window = NULL;
+ if (impl) {
+ callback = impl->get_core_event_callback();
+ main_window = NATIVE_WINDOW_CAST(impl->get_main_window());
+ }
+
+#ifndef APPLY_WINDOW_MANAGER_CHANGE
+#else
+ if (ev->message_type == ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE) {
+ LOGD("ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE , %d %d\n", ev->data.l[0], gFHiddenState);
+ angle = ev->data.l[0];
+ ise_set_screen_direction(angle);
+ if (!gFHiddenState) {
+ ise_show(gLastIC);
+ }
+ } else if (ev->message_type == ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_STATE) {
+ LOGD("ECORE_X_ATOM_E_VIRTUAL_KEYBOARD_STATE , %d\n", ev->data.l[0]);
+ elm_win_keyboard_mode_set(main_window, (Elm_Win_Keyboard_Mode)(ev->data.l[0]));
+ gFHiddenState = !(ev->data.l[0]);
+ }
+#endif
+
+ if (ev->message_type == ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST) {
+ if (ev->win == elm_win_xwindow_get(main_window)) {
+ int degree = ev->data.l[1];
+ CSCLCoreUIEFL *coreui = static_cast<CSCLCoreUIEFL*>(data);
+ if (coreui) {
+ coreui->set_screen_rotation_degree(degree);
+ }
+ LOGD("_ECORE_X_ATOM_E_WINDOW_ROTATION_REQUEST, %d\n", degree);
+ if (callback) {
+ callback->on_set_rotation_degree(degree);
+ }
+ Ecore_X_Window control_window = 0;
+ Ecore_X_Atom atom = ecore_x_atom_get ("_ISF_CONTROL_WINDOW");
+ Ecore_X_Window root = ecore_x_window_root_first_get ();
+ if (ecore_x_window_prop_xid_get(root, atom, ECORE_X_ATOM_WINDOW, &control_window, 1) == 1) {
+ ecore_x_client_message32_send(control_window, ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST,
+ ECORE_X_EVENT_MASK_WINDOW_CONFIGURE,
+ ev->data.l[0], ev->data.l[1], ev->data.l[2], ev->data.l[3], ev->data.l[4]);
+ }
+ }
+ }
+
+ return ECORE_CALLBACK_RENEW;
+}
+
+int CSCLCoreUIEFL::get_screen_rotation_degree()
+{
+ int angle = 0;
+ if (m_rotation_degree == -1) {
+ int ret = 0;
+ Atom type_return;
+ int format_return;
+ unsigned long nitems_return;
+ unsigned long bytes_after_return;
+ unsigned char *data_window = NULL;
+ unsigned char *data_angle = NULL;
+
+ Ecore_X_Window app_window = 0;
+
+ Evas_Object *keypad_win = NATIVE_WINDOW_CAST(m_main_window);
+
+ LOGD("Trying to get app window degree for %p\n", keypad_win);
+ Ecore_X_Window win = elm_win_xwindow_get(NATIVE_WINDOW_CAST(keypad_win));
+ ret = XGetWindowProperty((Display *)ecore_x_display_get (),
+ ecore_x_window_root_get(win),
+ ecore_x_atom_get("_ISF_ACTIVE_WINDOW"),
+ 0, G_MAXLONG, False, XA_WINDOW, &type_return,
+ &format_return, &nitems_return, &bytes_after_return,
+ &data_window);
+
+ if (ret == Success) {
+ if ((type_return == XA_WINDOW) && (format_return == 32) && (data_window)) {
+ app_window = *(Window *)data_window;
+
+ ret = XGetWindowProperty((Display *)ecore_x_display_get(), app_window,
+ ecore_x_atom_get("_E_ILLUME_ROTATE_WINDOW_ANGLE"),
+ 0, G_MAXLONG, False, XA_CARDINAL, &type_return,
+ &format_return, &nitems_return, &bytes_after_return,
+ &data_angle);
+
+ LOGD("app_window : %p, ret %d, %d, %p\n", app_window, ret, type_return, data_angle);
+ if (ret == Success) {
+ if (data_angle) {
+ if (type_return == XA_CARDINAL) {
+ angle = *(unsigned int*)data_angle;
+ LOGD("current rotation angle is %p %d\n", app_window, angle);
+ }
+ XFree(data_angle);
+ }
+ }
+ }
+ if (data_window)
+ XFree(data_window);
+ }
+ } else {
+ angle = m_rotation_degree;
+ }
+
+ return angle;
+}
+
+void signal_handler(int sig) {
+ elm_exit();
+}
+
+void CSCLCoreUIEFL::run(const sclchar *display)
+{
+ char *argv[4];
+ int argc = 3;
+
+ std::string name;
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ SclCoreAppInfo appinfo;
+ callback->on_get_app_info(&appinfo);
+ name = appinfo.name;
+ }
+
+ argv [0] = const_cast<char *> (name.c_str());
+ argv [1] = (char *)"--display";
+ argv [2] = const_cast<char *> (display);
+ argv [3] = 0;
+
+ elm_init(argc, argv);
+
+ elm_policy_set (ELM_POLICY_THROTTLE, ELM_POLICY_THROTTLE_NEVER);
+
+ Evas_Object *main_window = elm_win_add(NULL, "Tizen Keyboard", ELM_WIN_UTILITY);
+ m_main_window = SCL_WINDOW_CAST(main_window);
+
+ //elm_win_alpha_set(main_window, EINA_TRUE);
+ elm_win_borderless_set(main_window, EINA_TRUE);
+ elm_win_keyboard_win_set(main_window, EINA_TRUE);
+ elm_win_autodel_set(main_window, EINA_TRUE);
+ elm_win_title_set(main_window, "Tizen Keyboard");
+ unsigned int set = 1;
+ ecore_x_window_prop_card32_set(elm_win_xwindow_get(main_window),
+ ECORE_X_ATOM_E_WINDOW_ROTATION_SUPPORTED,
+ &set, 1);
+
+#ifdef FULL_SCREEN_TEST
+ elm_win_fullscreen_set(main_window, EINA_TRUE);
+#endif
+
+ /*Evas_Object *box = elm_box_add(main_window);
+ evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
+ elm_win_resize_object_add(main_window, box);*/
+
+ vconf_notify_key_changed(VCONFKEY_LANGSET, language_changed_cb, NULL);
+ vconf_notify_key_changed(VCONFKEY_SETAPPL_WIDGET_THEME_STR, theme_changed_cb, NULL);
+ vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, accessibility_changed_cb, NULL);
+
+ /* Should we call these callback functions here? */
+ language_changed_cb(NULL, NULL);
+ theme_changed_cb(NULL, NULL);
+ accessibility_changed_cb(NULL, NULL);
+
+ impl->init(display);
+
+ Ecore_Event_Handler *XClientMsgHandler =
+ ecore_event_handler_add (ECORE_X_EVENT_CLIENT_MESSAGE, _client_message_cb, this);
+
+ signal(SIGQUIT, signal_handler);
+ signal(SIGTERM, signal_handler);
+ signal(SIGINT, signal_handler);
+ signal(SIGHUP, signal_handler);
+
+ elm_run();
+
+ impl->fini();
+
+ vconf_ignore_key_changed(VCONFKEY_LANGSET, language_changed_cb);
+ vconf_ignore_key_changed(VCONFKEY_SETAPPL_WIDGET_THEME_STR, theme_changed_cb);
+ vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, accessibility_changed_cb);
+
+ ecore_event_handler_del(XClientMsgHandler);
+
+ elm_shutdown();
+ }
+}
+
+static Eina_Bool focus_out_cb(void *data, int type, void *event)
+{
+ OptionWindowInfo *info = static_cast<OptionWindowInfo*>(data);
+ if (info) {
+ if (info->window) {
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_destroy_option_window(info->window);
+ }
+ }
+
+ evas_object_hide(NATIVE_WINDOW_CAST(info->window));
+ evas_object_del(NATIVE_WINDOW_CAST(info->window));
+ info->window = NULL;
+ }
+ if (info->handler) {
+ ecore_event_handler_del(info->handler);
+ info->handler = NULL;
+ }
+ }
+
+ return ECORE_CALLBACK_CANCEL;
+}
+
+static void
+set_transient_for_app_window(Evas_Object *window)
+{
+ /* Set a transient window for window stack */
+ /* Gets the current XID of the active window into the root window property */
+ Atom type_return;
+ unsigned long nitems_return;
+ unsigned long bytes_after_return;
+ int format_return;
+ unsigned char *data = NULL;
+ Ecore_X_Window xAppWindow;
+ Ecore_X_Window xWindow = elm_win_xwindow_get(window);
+ gint ret = 0;
+
+ ret = XGetWindowProperty ((Display *)ecore_x_display_get(), ecore_x_window_root_get(xWindow),
+ ecore_x_atom_get("_ISF_ACTIVE_WINDOW"),
+ 0, G_MAXLONG, False, XA_WINDOW, &type_return,
+ &format_return, &nitems_return, &bytes_after_return,
+ &data);
+
+ if (ret == Success) {
+ if (data) {
+ if (type_return == XA_WINDOW) {
+ xAppWindow = *(Window *)data;
+ LOGD("TRANSIENT_FOR SET : %x , %x", xAppWindow, xWindow);
+ ecore_x_icccm_transient_for_set(xWindow, xAppWindow);
+ }
+ XFree(data);
+ }
+ }
+}
+
+sclwindow CSCLCoreUIEFL::create_option_window(SCLOptionWindowType type)
+{
+ if (type < 0 || type >= OPTION_WINDOW_TYPE_MAX) {
+ return SCLWINDOW_INVALID;
+ }
+
+ Evas_Object *window = elm_win_util_standard_add("Option window", "Option window");
+
+ const char *szProfile[] = {"mobile", ""};
+ elm_win_profiles_set(window, szProfile, 1);
+
+ elm_win_borderless_set(window, EINA_TRUE);
+
+ Evas_Coord win_w = 0, win_h = 0;
+ ecore_x_window_size_get(ecore_x_window_root_first_get(), &win_w, &win_h);
+ int degree = get_screen_rotation_degree();
+ if(degree == 90 || degree == 270){
+ evas_object_resize(window, win_h, win_w);
+ }else{
+ evas_object_resize(window, win_w, win_h);
+ }
+
+ int rots[] = { 0, 90, 180, 270 };
+ elm_win_wm_rotation_available_rotations_set(window, rots, (sizeof(rots) / sizeof(int)));
+
+ elm_win_indicator_mode_set (window, ELM_WIN_INDICATOR_SHOW);
+
+ Ecore_Event_Handler *handler = NULL;
+ if (type == OPTION_WINDOW_TYPE_NORMAL) {
+ handler = ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT, focus_out_cb, &m_option_window_info[type]);
+ set_transient_for_app_window(window);
+ }
+
+ m_option_window_info[type].window = window;
+ m_option_window_info[type].handler = handler;
+
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_create_option_window(window, type);
+ }
+ }
+
+ return window;
+}
+
+void CSCLCoreUIEFL::destroy_option_window(sclwindow window)
+{
+ CSCLCoreImpl *impl = CSCLCoreImpl::get_instance();
+ if (impl) {
+ ISCLCoreEventCallback *callback = impl->get_core_event_callback();
+ if (callback) {
+ callback->on_destroy_option_window(window);
+ }
+ }
+
+ for (int loop = 0;loop < OPTION_WINDOW_TYPE_MAX;loop++) {
+ if (m_option_window_info[loop].window == window) {
+ m_option_window_info[OPTION_WINDOW_TYPE_NORMAL].window = SCLWINDOW_INVALID;
+ if (m_option_window_info[loop].handler) {
+ ecore_event_handler_del(m_option_window_info[loop].handler);
+ m_option_window_info[loop].handler = NULL;
+ }
+ }
+ }
+ evas_object_del(NATIVE_WINDOW_CAST(window));
+}
+
+void CSCLCoreUIEFL::set_screen_rotation_degree(int degree)
+{
+ m_rotation_degree = degree;
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __SCL_CORE_UI_EFL_H__
+#define __SCL_CORE_UI_EFL_H__
+
+#include "sclcoreui.h"
+
+#include <Ecore.h>
+
+//SCL_BEGIN_DECLS
+
+namespace scl
+{
+
+typedef struct {
+ sclwindow window;
+ Ecore_Event_Handler *handler;
+} OptionWindowInfo;
+
+class CSCLCoreUIEFL : public CSCLCoreUI
+{
+public:
+ CSCLCoreUIEFL();
+ ~CSCLCoreUIEFL();
+
+ virtual sclboolean init();
+ virtual void fini();
+
+ virtual void run(const sclchar *display);
+ virtual sclwindow get_main_window();
+ virtual void set_keyboard_size_hints(SclSize portrait, SclSize landscape);
+ virtual int get_screen_rotation_degree();
+
+ virtual sclwindow create_option_window(SCLOptionWindowType type);
+ virtual void destroy_option_window(sclwindow window);
+
+ void set_screen_rotation_degree(int degree);
+private:
+ sclboolean m_initialized;
+
+ sclint m_rotation_degree;
+ sclwindow m_main_window;
+
+ OptionWindowInfo m_option_window_info[OPTION_WINDOW_TYPE_MAX];
+};
+
+}
+
+//SCL_END_DECLS
+
+#endif //__SCL_CORE_UI_EFL_H__
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "sclcoreui.h"
+
+#include "sclcoreui-efl.h"
+
+using namespace scl;
+
+CSCLCoreUI::CSCLCoreUI()
+{
+ m_backend_identifier = "undefined";
+ m_impl = NULL;
+}
+
+CSCLCoreUI::~CSCLCoreUI()
+{
+}
+
+std::string CSCLCoreUI::get_backend_indentifier()
+{
+ return m_backend_identifier;
+}
+
+sclboolean CSCLCoreUI::init()
+{
+ sclboolean ret = FALSE;
+ if (m_impl == NULL) {
+ /* There could be other backend implementations.. */
+ m_impl = new CSCLCoreUIEFL;
+ }
+ if (m_impl) {
+ ret = m_impl->init();
+ }
+ return ret;
+}
+
+void CSCLCoreUI::fini()
+{
+ if (m_impl) {
+ m_impl->fini();
+ delete m_impl;
+ m_impl = NULL;
+ }
+}
+
+void CSCLCoreUI::run(const sclchar *display)
+{
+ if (m_impl) {
+ m_impl->run(display);
+ }
+}
+
+void CSCLCoreUI::set_keyboard_size_hints(SclSize portrait, SclSize landscape)
+{
+ if (m_impl) {
+ m_impl->set_keyboard_size_hints(portrait, landscape);
+ }
+}
+
+sclwindow CSCLCoreUI::get_main_window()
+{
+ sclwindow ret = SCLWINDOW_INVALID;
+ if (m_impl) {
+ ret = m_impl->get_main_window();
+ }
+ return ret;
+}
+
+int CSCLCoreUI::get_screen_rotation_degree()
+{
+ int ret = 0;
+ if (m_impl) {
+ ret = m_impl->get_screen_rotation_degree();
+ }
+ return ret;
+}
+
+sclwindow CSCLCoreUI::create_option_window(SCLOptionWindowType type)
+{
+ sclwindow ret = SCLWINDOW_INVALID;
+ if (m_impl) {
+ ret = m_impl->create_option_window(type);
+ }
+ return ret;
+}
+
+void CSCLCoreUI::destroy_option_window(sclwindow window)
+{
+ if (m_impl) {
+ m_impl->destroy_option_window(window);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2012 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __SCL_CORE_UI_H__
+#define __SCL_CORE_UI_H__
+
+//SCL_BEGIN_DECLS
+#include <string>
+
+#include "scltypes.h"
+#include "sclcorecallback.h"
+
+namespace scl
+{
+
+/**
+ * @brief The base class that provides features for a soft-keyboard
+ *
+ * This class implements all functions for working as a soft-based keyboard
+ */
+class CSCLCoreUI
+{
+public:
+ CSCLCoreUI();
+ ~CSCLCoreUI();
+
+ std::string get_backend_indentifier();
+
+ virtual sclboolean init();
+ virtual void fini();
+
+ virtual void run(const sclchar *display);
+
+ /**
+ * @brief This API returns the pointer to main keyboard window
+ */
+ virtual sclwindow get_main_window();
+
+ /**
+ * @brief This API returns the rotation angle of the current screen
+ */
+ virtual int get_screen_rotation_degree();
+
+ /**
+ * @brief This API updates the keyboard window's geometry information
+ */
+ virtual void set_keyboard_size_hints(SclSize portrait, SclSize landscape);
+
+ /**
+ * @brief Requests to create an option window
+ */
+ virtual sclwindow create_option_window(SCLOptionWindowType type);
+
+ /**
+ * @brief Requests to destroy an option window
+ */
+ virtual void destroy_option_window(sclwindow window);
+
+protected:
+ std::string m_backend_identifier;
+
+private:
+ CSCLCoreUI *m_impl;
+};
+
+}
+
+//SCL_END_DECLS
+
+#endif //__SCL_CORE_UI_H__
projects / platform / core / uifw / libscl-core.git / commitdiff