X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Fecore%2Fwayland%2Fimf-manager-impl-ecore-wl.cpp;h=5764c3a8fcc0b31e26afe9266473680abd9a68ea;hb=a7a4e677915974dec21da2af195886c7b798e11b;hp=833b125284bebf8441ddbc5553cbc1d32f71f1cd;hpb=3cb00bb8024e2690ef766bf0d2f7c007a5ed4e16;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/adaptors/ecore/wayland/imf-manager-impl-ecore-wl.cpp b/adaptors/ecore/wayland/imf-manager-impl-ecore-wl.cpp index 833b125..5764c3a 100644 --- a/adaptors/ecore/wayland/imf-manager-impl-ecore-wl.cpp +++ b/adaptors/ecore/wayland/imf-manager-impl-ecore-wl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2017 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,6 +16,9 @@ */ // CLASS HEADER +// Ecore is littered with C style cast +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" #include // EXTERNAL INCLUDES @@ -24,12 +27,53 @@ #include // INTERNAL INCLUDES +#include #include +#include #include #include #include -#include -#include "ecore-virtual-keyboard.h" + +#define TOKEN_STRING(x) #x + +Ecore_IMF_Input_Panel_Layout panelLayoutMap[] = +{ + ECORE_IMF_INPUT_PANEL_LAYOUT_NORMAL, + ECORE_IMF_INPUT_PANEL_LAYOUT_NUMBER, + ECORE_IMF_INPUT_PANEL_LAYOUT_EMAIL, + ECORE_IMF_INPUT_PANEL_LAYOUT_URL, + ECORE_IMF_INPUT_PANEL_LAYOUT_PHONENUMBER, + ECORE_IMF_INPUT_PANEL_LAYOUT_IP, + ECORE_IMF_INPUT_PANEL_LAYOUT_MONTH, + ECORE_IMF_INPUT_PANEL_LAYOUT_NUMBERONLY, + ECORE_IMF_INPUT_PANEL_LAYOUT_HEX, + ECORE_IMF_INPUT_PANEL_LAYOUT_TERMINAL, + ECORE_IMF_INPUT_PANEL_LAYOUT_PASSWORD, + ECORE_IMF_INPUT_PANEL_LAYOUT_DATETIME, + ECORE_IMF_INPUT_PANEL_LAYOUT_EMOTICON, + ECORE_IMF_INPUT_PANEL_LAYOUT_VOICE +}; + +Ecore_IMF_Autocapital_Type autoCapitalMap[] = +{ + ECORE_IMF_AUTOCAPITAL_TYPE_NONE, + ECORE_IMF_AUTOCAPITAL_TYPE_WORD, + ECORE_IMF_AUTOCAPITAL_TYPE_SENTENCE, + ECORE_IMF_AUTOCAPITAL_TYPE_ALLCHARACTER, +}; + +Ecore_IMF_Input_Panel_Return_Key_Type returnKeyTypeMap[] = +{ + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT, + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_DONE, + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_GO, + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_JOIN, + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_LOGIN, + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_NEXT, + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_SEARCH, + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_SEND, + ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_SIGNIN +}; namespace Dali { @@ -103,6 +147,83 @@ Eina_Bool ImfRetrieveSurrounding(void *data, Ecore_IMF_Context *imfContext, char } } +void InputPanelStateChangeCallback( void* data, Ecore_IMF_Context* context, int value ) +{ + if (!data) + { + return; + } + ImfManager* imfManager = reinterpret_cast< ImfManager* > ( data ); + switch (value) + { + case ECORE_IMF_INPUT_PANEL_STATE_SHOW: + { + imfManager->StatusChangedSignal().Emit( true ); + break; + } + + case ECORE_IMF_INPUT_PANEL_STATE_HIDE: + { + imfManager->StatusChangedSignal().Emit( false ); + break; + } + + case ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW: + default: + { + // Do nothing + break; + } + } +} + +void InputPanelLanguageChangeCallback( void* data, Ecore_IMF_Context* context, int value ) +{ + if (!data) + { + return; + } + ImfManager* imfManager = reinterpret_cast< ImfManager* > ( data ); + // Emit the signal that the language has changed + imfManager->LanguageChangedSignal().Emit(); +} + +void InputPanelGeometryChangedCallback ( void *data, Ecore_IMF_Context *context, int value ) +{ + if (!data) + { + return; + } + ImfManager* imfManager = reinterpret_cast< ImfManager* > ( data ); + // Emit signal that the keyboard is resized + imfManager->ResizedSignal().Emit(); +} + +void InputPanelKeyboardTypeChangedCallback( void *data, Ecore_IMF_Context *context, int value ) +{ + if( !data ) + { + return; + } + + ImfManager* imfManager = reinterpret_cast< ImfManager* > ( data ); + switch (value) + { + case ECORE_IMF_INPUT_PANEL_SW_KEYBOARD_MODE: + { + // Emit Signal that the keyboard type is changed to Software Keyboard + imfManager->KeyboardTypeChangedSignal().Emit( Dali::ImfManager::KeyboardType::SOFTWARE_KEYBOARD ); + break; + } + case ECORE_IMF_INPUT_PANEL_HW_KEYBOARD_MODE: + { + // Emit Signal that the keyboard type is changed to Hardware Keyboard + imfManager->KeyboardTypeChangedSignal().Emit( Dali::ImfManager::KeyboardType::HARDWARE_KEYBOARD ); + break; + } + } +} + /** * Called when an IMF delete surrounding event is received. * Here we tell the application that it should delete a certain range. @@ -116,6 +237,18 @@ void ImfDeleteSurrounding( void *data, Ecore_IMF_Context *imfContext, void *even } } +/** + * Called when the input method sends a private command. + */ +void PrivateCommand( void *data, Ecore_IMF_Context *imfContext, void *event_info ) +{ + if ( data ) + { + ImfManager* imfManager = reinterpret_cast< ImfManager* > ( data ); + imfManager->SendPrivateCommand( data, imfContext, event_info ); + } +} + BaseHandle Create() { return ImfManager::Get(); @@ -173,7 +306,7 @@ Dali::ImfManager ImfManager::Get() } else { - DALI_LOG_ERROR("Failed to get native window handle"); + DALI_LOG_ERROR("Failed to get native window handle\n"); } } } @@ -192,12 +325,10 @@ ImfManager::ImfManager( Ecore_Wl_Window *ecoreWlwin ) CreateContext( ecoreWlwin ); ConnectCallbacks(); - VirtualKeyboard::ConnectCallbacks( mIMFContext ); } ImfManager::~ImfManager() { - VirtualKeyboard::DisconnectCallbacks( mIMFContext ); DisconnectCallbacks(); DeleteContext(); @@ -239,6 +370,7 @@ void ImfManager::DeleteContext() if ( mIMFContext ) { + ecore_imf_context_del( mIMFContext ); mIMFContext = NULL; } } @@ -250,9 +382,15 @@ void ImfManager::ConnectCallbacks() { DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::ConnectCallbacks\n" ); - ecore_imf_context_event_callback_add( mIMFContext, ECORE_IMF_CALLBACK_PREEDIT_CHANGED, PreEdit, this ); - ecore_imf_context_event_callback_add( mIMFContext, ECORE_IMF_CALLBACK_COMMIT, Commit, this ); - ecore_imf_context_event_callback_add( mIMFContext, ECORE_IMF_CALLBACK_DELETE_SURROUNDING, ImfDeleteSurrounding, this ); + ecore_imf_context_event_callback_add( mIMFContext, ECORE_IMF_CALLBACK_PREEDIT_CHANGED, PreEdit, this ); + ecore_imf_context_event_callback_add( mIMFContext, ECORE_IMF_CALLBACK_COMMIT, Commit, this ); + ecore_imf_context_event_callback_add( mIMFContext, ECORE_IMF_CALLBACK_DELETE_SURROUNDING, ImfDeleteSurrounding, this ); + ecore_imf_context_event_callback_add( mIMFContext, ECORE_IMF_CALLBACK_PRIVATE_COMMAND_SEND, PrivateCommand, this ); + + ecore_imf_context_input_panel_event_callback_add( mIMFContext, ECORE_IMF_INPUT_PANEL_STATE_EVENT, InputPanelStateChangeCallback, this ); + ecore_imf_context_input_panel_event_callback_add( mIMFContext, ECORE_IMF_INPUT_PANEL_LANGUAGE_EVENT, InputPanelLanguageChangeCallback, this ); + ecore_imf_context_input_panel_event_callback_add( mIMFContext, ECORE_IMF_INPUT_PANEL_GEOMETRY_EVENT, InputPanelGeometryChangedCallback, this ); + ecore_imf_context_input_panel_event_callback_add( mIMFContext, ECORE_IMF_INPUT_PANEL_KEYBOARD_MODE_EVENT, InputPanelKeyboardTypeChangedCallback, this ); ecore_imf_context_retrieve_surrounding_callback_set( mIMFContext, ImfRetrieveSurrounding, this); } @@ -264,9 +402,15 @@ void ImfManager::DisconnectCallbacks() { DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::DisconnectCallbacks\n" ); - ecore_imf_context_event_callback_del( mIMFContext, ECORE_IMF_CALLBACK_PREEDIT_CHANGED, PreEdit ); - ecore_imf_context_event_callback_del( mIMFContext, ECORE_IMF_CALLBACK_COMMIT, Commit ); - ecore_imf_context_event_callback_del( mIMFContext, ECORE_IMF_CALLBACK_DELETE_SURROUNDING, ImfDeleteSurrounding ); + ecore_imf_context_event_callback_del( mIMFContext, ECORE_IMF_CALLBACK_PREEDIT_CHANGED, PreEdit ); + ecore_imf_context_event_callback_del( mIMFContext, ECORE_IMF_CALLBACK_COMMIT, Commit ); + ecore_imf_context_event_callback_del( mIMFContext, ECORE_IMF_CALLBACK_DELETE_SURROUNDING, ImfDeleteSurrounding ); + ecore_imf_context_event_callback_del( mIMFContext, ECORE_IMF_CALLBACK_PRIVATE_COMMAND_SEND, PrivateCommand ); + + ecore_imf_context_input_panel_event_callback_del( mIMFContext, ECORE_IMF_INPUT_PANEL_STATE_EVENT, InputPanelStateChangeCallback ); + ecore_imf_context_input_panel_event_callback_del( mIMFContext, ECORE_IMF_INPUT_PANEL_LANGUAGE_EVENT, InputPanelLanguageChangeCallback ); + ecore_imf_context_input_panel_event_callback_del( mIMFContext, ECORE_IMF_INPUT_PANEL_GEOMETRY_EVENT, InputPanelGeometryChangedCallback ); + ecore_imf_context_input_panel_event_callback_del( mIMFContext, ECORE_IMF_INPUT_PANEL_KEYBOARD_MODE_EVENT, InputPanelKeyboardTypeChangedCallback ); // We do not need to unset the retrieve surrounding callback. } @@ -478,6 +622,23 @@ void ImfManager::DeleteSurrounding( void* data, Ecore_IMF_Context* imfContext, v } } +/** + * Called when the input method sends a private command. + */ +void ImfManager::SendPrivateCommand( void* data, Ecore_IMF_Context* imfContext, void* event_info ) +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::SendPrivateCommand\n" ); + + if( Dali::Adaptor::IsAvailable() ) + { + const char* privateCommandSendEvent = static_cast( event_info ); + + Dali::ImfManager::ImfEventData imfData( Dali::ImfManager::PRIVATECOMMAND, privateCommandSendEvent, 0, 0 ); + Dali::ImfManager handle( this ); + mEventSignal.Emit( handle, imfData ); + } +} + void ImfManager::NotifyCursorPosition() { DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::NotifyCursorPosition\n" ); @@ -516,8 +677,240 @@ const std::string& ImfManager::GetSurroundingText() const return mSurroundingText; } +void ImfManager::NotifyTextInputMultiLine( bool multiLine ) +{ + Ecore_IMF_Input_Hints currentHint = ecore_imf_context_input_hint_get(mIMFContext); + ecore_imf_context_input_hint_set( mIMFContext, + static_cast< Ecore_IMF_Input_Hints >( multiLine ? + (currentHint | ECORE_IMF_INPUT_HINT_MULTILINE) : + (currentHint & ~ECORE_IMF_INPUT_HINT_MULTILINE))); +} + +Dali::ImfManager::TextDirection ImfManager::GetTextDirection() +{ + Dali::ImfManager::TextDirection direction ( Dali::ImfManager::LeftToRight ); + + if ( ImfManager::IsAvailable() /* We do not want to create an instance of ImfManager */ ) + { + if ( mIMFContext ) + { + char* locale( NULL ); + ecore_imf_context_input_panel_language_locale_get( mIMFContext, &locale ); + + if ( locale ) + { + direction = Locale::GetTextDirection( std::string( locale ) ); + free( locale ); + } + } + } + return direction; +} + +Rect ImfManager::GetInputMethodArea() +{ + int xPos, yPos, width, height; + + width = height = xPos = yPos = 0; + + if( mIMFContext ) + { + ecore_imf_context_input_panel_geometry_get( mIMFContext, &xPos, &yPos, &width, &height ); + } + else + { + DALI_LOG_WARNING("VKB Unable to get IMF Context so GetSize unavailable\n"); + // return 0 as real size unknown. + } + + return Rect(xPos,yPos,width,height); +} + +void ImfManager::ApplyOptions( const InputMethodOptions& options ) +{ + using namespace Dali::InputMethod::Category; + + int index; + + if (mIMFContext == NULL) + { + DALI_LOG_WARNING("VKB Unable to excute ApplyOptions with Null ImfContext\n"); + return; + } + + if ( mOptions.CompareAndSet(PANEL_LAYOUT, options, index) ) + { + ecore_imf_context_input_panel_layout_set( mIMFContext, panelLayoutMap[index] ); + } + if ( mOptions.CompareAndSet(AUTO_CAPITALISE, options, index) ) + { + ecore_imf_context_autocapital_type_set( mIMFContext, autoCapitalMap[index] ); + } + if ( mOptions.CompareAndSet(ACTION_BUTTON_TITLE, options, index) ) + { + ecore_imf_context_input_panel_return_key_type_set( mIMFContext, returnKeyTypeMap[index] ); + } + if ( mOptions.CompareAndSet(VARIATION, options, index) ) + { + ecore_imf_context_input_panel_layout_variation_set( mIMFContext, index ); + } +} + +void ImfManager::SetInputPanelUserData( const std::string& data ) +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::SetInputPanelUserData\n" ); + + if( mIMFContext ) + { + int length = data.length(); + ecore_imf_context_input_panel_imdata_set( mIMFContext, &data, length ); + } +} + +void ImfManager::GetInputPanelUserData( std::string& data ) +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::GetInputPanelUserData\n" ); + + if( mIMFContext ) + { + int* length = NULL; + ecore_imf_context_input_panel_imdata_get( mIMFContext, &data, length ); + } +} + +Dali::ImfManager::State ImfManager::GetInputPanelState() +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::GetInputPanelState\n" ); + + if( mIMFContext ) + { + int value; + value = ecore_imf_context_input_panel_state_get( mIMFContext ); + + switch (value) + { + case ECORE_IMF_INPUT_PANEL_STATE_SHOW: + { + return Dali::ImfManager::SHOW; + break; + } + + case ECORE_IMF_INPUT_PANEL_STATE_HIDE: + { + return Dali::ImfManager::HIDE; + break; + } + + case ECORE_IMF_INPUT_PANEL_STATE_WILL_SHOW: + { + return Dali::ImfManager::WILL_SHOW; + break; + } + + default: + { + return Dali::ImfManager::DEFAULT; + } + } + } + return Dali::ImfManager::DEFAULT; +} + +void ImfManager::SetReturnKeyState( bool visible ) +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::SetReturnKeyState\n" ); + + if( mIMFContext ) + { + ecore_imf_context_input_panel_return_key_disabled_set( mIMFContext, !visible ); + } +} + +void ImfManager::AutoEnableInputPanel( bool enabled ) +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::AutoEnableInputPanel\n" ); + + if( mIMFContext ) + { + ecore_imf_context_input_panel_enabled_set( mIMFContext, enabled ); + } +} + +void ImfManager::ShowInputPanel() +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::ShowInputPanel\n" ); + + if( mIMFContext ) + { + ecore_imf_context_input_panel_show( mIMFContext ); + } +} + +void ImfManager::HideInputPanel() +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::HideInputPanel\n" ); + + if( mIMFContext ) + { + ecore_imf_context_input_panel_hide( mIMFContext ); + } +} + +Dali::ImfManager::KeyboardType ImfManager::GetKeyboardType() +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::GetKeyboardType\n" ); + +#ifdef OVER_TIZEN_VERSION_4 + if( mIMFContext ) + { + int value; + value = ecore_imf_context_keyboard_mode_get( mIMFContext ); + + switch (value) + { + case ECORE_IMF_INPUT_PANEL_SW_KEYBOARD_MODE: + { + return Dali::ImfManager::SOFTWARE_KEYBOARD; + break; + } + case ECORE_IMF_INPUT_PANEL_HW_KEYBOARD_MODE: + { + return Dali::ImfManager::HARDWARE_KEYBOARD; + break; + } + } + } +#endif // OVER_TIZEN_VERSION_4 + return Dali::ImfManager::KeyboardType::SOFTWARE_KEYBOARD; +} + +std::string ImfManager::GetInputPanelLocale() +{ + DALI_LOG_INFO( gLogFilter, Debug::General, "ImfManager::GetInputPanelLocale\n" ); + + std::string locale = ""; + + if( mIMFContext ) + { + char* value = NULL; + ecore_imf_context_input_panel_language_locale_get( mIMFContext, &value ); + + if( value ) + { + std::string valueCopy( value ); + locale = valueCopy; + + // The locale string retrieved must be freed with free(). + free( value ); + } + } + return locale; +} + } // Adaptor } // Internal } // Dali + +#pragma GCC diagnostic pop