X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Ftext-controller.cpp;h=27b982f3d42b2f816417b76c4d9dcceb35304fa9;hp=a5022004da00733d9ea835ae736e3deebf05d8ae;hb=a9c2fdd131a2f08af2f04565c376d6e0e158d5b1;hpb=964dd7f6a94f280063595dbb48fb8f1232836789 diff --git a/dali-toolkit/internal/text/text-controller.cpp b/dali-toolkit/internal/text/text-controller.cpp old mode 100644 new mode 100755 index a502200..27b982f --- a/dali-toolkit/internal/text/text-controller.cpp +++ b/dali-toolkit/internal/text/text-controller.cpp @@ -25,14 +25,18 @@ #include #include #include +#include // INTERNAL INCLUDES +#include #include #include #include #include +#include #include #include +#include namespace { @@ -45,6 +49,19 @@ const float MAX_FLOAT = std::numeric_limits::max(); const std::string EMPTY_STRING(""); +const std::string KEY_C_NAME = "c"; +const std::string KEY_V_NAME = "v"; +const std::string KEY_X_NAME = "x"; + +const char * const PLACEHOLDER_TEXT = "text"; +const char * const PLACEHOLDER_TEXT_FOCUSED = "textFocused"; +const char * const PLACEHOLDER_COLOR = "color"; +const char * const PLACEHOLDER_FONT_FAMILY = "fontFamily"; +const char * const PLACEHOLDER_FONT_STYLE = "fontStyle"; +const char * const PLACEHOLDER_POINT_SIZE = "pointSize"; +const char * const PLACEHOLDER_PIXEL_SIZE = "pixelSize"; +const char * const PLACEHOLDER_ELLIPSIS = "ellipsis"; + float ConvertToEven( float value ) { int intValue(static_cast( value )); @@ -334,6 +351,7 @@ void Controller::SetMultiLineEnabled( bool enable ) ALIGN | REORDER ); + mImpl->mTextUpdateInfo.mFullRelayoutNeeded = true; mImpl->mOperationsPending = static_cast( mImpl->mOperationsPending | layoutOperations ); mImpl->RequestRelayout(); @@ -345,7 +363,7 @@ bool Controller::IsMultiLineEnabled() const return Layout::Engine::MULTI_LINE_BOX == mImpl->mLayoutEngine.GetLayout(); } -void Controller::SetHorizontalAlignment( Layout::HorizontalAlignment alignment ) +void Controller::SetHorizontalAlignment( Text::HorizontalAlignment::Type alignment ) { if( alignment != mImpl->mModel->mHorizontalAlignment ) { @@ -359,12 +377,12 @@ void Controller::SetHorizontalAlignment( Layout::HorizontalAlignment alignment ) } } -Layout::HorizontalAlignment Controller::GetHorizontalAlignment() const +Text::HorizontalAlignment::Type Controller::GetHorizontalAlignment() const { return mImpl->mModel->mHorizontalAlignment; } -void Controller::SetVerticalAlignment( Layout::VerticalAlignment alignment ) +void Controller::SetVerticalAlignment( VerticalAlignment::Type alignment ) { if( alignment != mImpl->mModel->mVerticalAlignment ) { @@ -377,11 +395,39 @@ void Controller::SetVerticalAlignment( Layout::VerticalAlignment alignment ) } } -Layout::VerticalAlignment Controller::GetVerticalAlignment() const +VerticalAlignment::Type Controller::GetVerticalAlignment() const { return mImpl->mModel->mVerticalAlignment; } +void Controller::SetLineWrapMode( Text::LineWrap::Mode lineWrapMode ) +{ + if( lineWrapMode != mImpl->mModel->mLineWrapMode ) + { + // Set the text wrap mode. + mImpl->mModel->mLineWrapMode = lineWrapMode; + + + // Update Text layout for applying wrap mode + mImpl->mOperationsPending = static_cast( mImpl->mOperationsPending | + ALIGN | + LAYOUT | + UPDATE_LAYOUT_SIZE | + REORDER ); + mImpl->mTextUpdateInfo.mCharacterIndex = 0u; + mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters; + mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mModel->mLogicalModel->mText.Count(); + + // Request relayout + mImpl->RequestRelayout(); + } +} + +Text::LineWrap::Mode Controller::GetLineWrapMode() const +{ + return mImpl->mModel->mLineWrapMode; +} + void Controller::SetTextElideEnabled( bool enabled ) { mImpl->mModel->mElideEnabled = enabled; @@ -392,6 +438,34 @@ bool Controller::IsTextElideEnabled() const return mImpl->mModel->mElideEnabled; } +void Controller::SetPlaceholderTextElideEnabled( bool enabled ) +{ + mImpl->mEventData->mIsPlaceholderElideEnabled = enabled; + mImpl->mEventData->mPlaceholderEllipsisFlag = true; + + // Update placeholder if there is no text + if( mImpl->IsShowingPlaceholderText() || + ( 0u == mImpl->mModel->mLogicalModel->mText.Count() ) ) + { + ShowPlaceholderText(); + } +} + +bool Controller::IsPlaceholderTextElideEnabled() const +{ + return mImpl->mEventData->mIsPlaceholderElideEnabled; +} + +void Controller::SetSelectionEnabled( bool enabled ) +{ + mImpl->mEventData->mSelectionEnabled = enabled; +} + +bool Controller::IsSelectionEnabled() const +{ + return mImpl->mEventData->mSelectionEnabled; +} + // public : Update void Controller::SetText( const std::string& text ) @@ -593,6 +667,33 @@ const std::string& Controller::GetDefaultFontFamily() const return EMPTY_STRING; } +void Controller::SetPlaceholderFontFamily( const std::string& placeholderTextFontFamily ) +{ + if( NULL != mImpl->mEventData ) + { + if( NULL == mImpl->mEventData->mPlaceholderFont ) + { + mImpl->mEventData->mPlaceholderFont = new FontDefaults(); + } + + mImpl->mEventData->mPlaceholderFont->mFontDescription.family = placeholderTextFontFamily; + DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetPlaceholderFontFamily %s\n", placeholderTextFontFamily.c_str()); + mImpl->mEventData->mPlaceholderFont->familyDefined = !placeholderTextFontFamily.empty(); + + mImpl->RequestRelayout(); + } +} + +const std::string& Controller::GetPlaceholderFontFamily() const +{ + if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) ) + { + return mImpl->mEventData->mPlaceholderFont->mFontDescription.family; + } + + return EMPTY_STRING; +} + void Controller::SetDefaultFontWeight( FontWeight weight ) { if( NULL == mImpl->mFontDefaults ) @@ -611,7 +712,12 @@ void Controller::SetDefaultFontWeight( FontWeight weight ) bool Controller::IsDefaultFontWeightDefined() const { - return mImpl->mFontDefaults->weightDefined; + if( NULL != mImpl->mFontDefaults ) + { + return mImpl->mFontDefaults->weightDefined; + } + + return false; } FontWeight Controller::GetDefaultFontWeight() const @@ -624,6 +730,41 @@ FontWeight Controller::GetDefaultFontWeight() const return TextAbstraction::FontWeight::NORMAL; } +void Controller::SetPlaceholderTextFontWeight( FontWeight weight ) +{ + if( NULL != mImpl->mEventData ) + { + if( NULL == mImpl->mEventData->mPlaceholderFont ) + { + mImpl->mEventData->mPlaceholderFont = new FontDefaults(); + } + + mImpl->mEventData->mPlaceholderFont->mFontDescription.weight = weight; + mImpl->mEventData->mPlaceholderFont->weightDefined = true; + + mImpl->RequestRelayout(); + } +} + +bool Controller::IsPlaceholderTextFontWeightDefined() const +{ + if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) ) + { + return mImpl->mEventData->mPlaceholderFont->weightDefined; + } + return false; +} + +FontWeight Controller::GetPlaceholderTextFontWeight() const +{ + if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) ) + { + return mImpl->mEventData->mPlaceholderFont->mFontDescription.weight; + } + + return TextAbstraction::FontWeight::NORMAL; +} + void Controller::SetDefaultFontWidth( FontWidth width ) { if( NULL == mImpl->mFontDefaults ) @@ -642,7 +783,12 @@ void Controller::SetDefaultFontWidth( FontWidth width ) bool Controller::IsDefaultFontWidthDefined() const { - return mImpl->mFontDefaults->widthDefined; + if( NULL != mImpl->mFontDefaults ) + { + return mImpl->mFontDefaults->widthDefined; + } + + return false; } FontWidth Controller::GetDefaultFontWidth() const @@ -655,6 +801,41 @@ FontWidth Controller::GetDefaultFontWidth() const return TextAbstraction::FontWidth::NORMAL; } +void Controller::SetPlaceholderTextFontWidth( FontWidth width ) +{ + if( NULL != mImpl->mEventData ) + { + if( NULL == mImpl->mEventData->mPlaceholderFont ) + { + mImpl->mEventData->mPlaceholderFont = new FontDefaults(); + } + + mImpl->mEventData->mPlaceholderFont->mFontDescription.width = width; + mImpl->mEventData->mPlaceholderFont->widthDefined = true; + + mImpl->RequestRelayout(); + } +} + +bool Controller::IsPlaceholderTextFontWidthDefined() const +{ + if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) ) + { + return mImpl->mEventData->mPlaceholderFont->widthDefined; + } + return false; +} + +FontWidth Controller::GetPlaceholderTextFontWidth() const +{ + if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) ) + { + return mImpl->mEventData->mPlaceholderFont->mFontDescription.width; + } + + return TextAbstraction::FontWidth::NORMAL; +} + void Controller::SetDefaultFontSlant( FontSlant slant ) { if( NULL == mImpl->mFontDefaults ) @@ -673,7 +854,11 @@ void Controller::SetDefaultFontSlant( FontSlant slant ) bool Controller::IsDefaultFontSlantDefined() const { - return mImpl->mFontDefaults->slantDefined; + if( NULL != mImpl->mFontDefaults ) + { + return mImpl->mFontDefaults->slantDefined; + } + return false; } FontSlant Controller::GetDefaultFontSlant() const @@ -686,6 +871,41 @@ FontSlant Controller::GetDefaultFontSlant() const return TextAbstraction::FontSlant::NORMAL; } +void Controller::SetPlaceholderTextFontSlant( FontSlant slant ) +{ + if( NULL != mImpl->mEventData ) + { + if( NULL == mImpl->mEventData->mPlaceholderFont ) + { + mImpl->mEventData->mPlaceholderFont = new FontDefaults(); + } + + mImpl->mEventData->mPlaceholderFont->mFontDescription.slant = slant; + mImpl->mEventData->mPlaceholderFont->slantDefined = true; + + mImpl->RequestRelayout(); + } +} + +bool Controller::IsPlaceholderTextFontSlantDefined() const +{ + if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) ) + { + return mImpl->mEventData->mPlaceholderFont->slantDefined; + } + return false; +} + +FontSlant Controller::GetPlaceholderTextFontSlant() const +{ + if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) ) + { + return mImpl->mEventData->mPlaceholderFont->mFontDescription.slant; + } + + return TextAbstraction::FontSlant::NORMAL; +} + void Controller::SetDefaultFontSize( float fontSize, FontSizeType type ) { if( NULL == mImpl->mFontDefaults ) @@ -703,20 +923,16 @@ void Controller::SetDefaultFontSize( float fontSize, FontSizeType type ) } case PIXEL_SIZE: { - // Point size = Pixel size * 72 / DPI + // Point size = Pixel size * 72.f / DPI unsigned int horizontalDpi = 0u; unsigned int verticalDpi = 0u; TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get(); fontClient.GetDpi( horizontalDpi, verticalDpi ); - mImpl->mFontDefaults->mDefaultPointSize = ( fontSize * 72 ) / horizontalDpi; + mImpl->mFontDefaults->mDefaultPointSize = ( fontSize * 72.f ) / static_cast< float >( horizontalDpi ); mImpl->mFontDefaults->sizeDefined = true; break; } - default: - { - DALI_ASSERT_ALWAYS( false ); - } } // Clear the font-specific data @@ -739,18 +955,97 @@ float Controller::GetDefaultFontSize( FontSizeType type ) const } case PIXEL_SIZE: { - // Pixel size = Point size * DPI / 72 + // Pixel size = Point size * DPI / 72.f unsigned int horizontalDpi = 0u; unsigned int verticalDpi = 0u; TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get(); fontClient.GetDpi( horizontalDpi, verticalDpi ); - value = mImpl->mFontDefaults->mDefaultPointSize * horizontalDpi / 72; + value = mImpl->mFontDefaults->mDefaultPointSize * static_cast< float >( horizontalDpi ) / 72.f; + break; + } + } + return value; + } + + return value; +} + +void Controller::SetPlaceholderTextFontSize( float fontSize, FontSizeType type ) +{ + if( NULL != mImpl->mEventData ) + { + if( NULL == mImpl->mEventData->mPlaceholderFont ) + { + mImpl->mEventData->mPlaceholderFont = new FontDefaults(); + } + + switch( type ) + { + case POINT_SIZE: + { + mImpl->mEventData->mPlaceholderFont->mDefaultPointSize = fontSize; + mImpl->mEventData->mPlaceholderFont->sizeDefined = true; + mImpl->mEventData->mIsPlaceholderPixelSize = false; // Font size flag break; } - default: + case PIXEL_SIZE: { - DALI_ASSERT_ALWAYS( false ); + // Point size = Pixel size * 72.f / DPI + unsigned int horizontalDpi = 0u; + unsigned int verticalDpi = 0u; + TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get(); + fontClient.GetDpi( horizontalDpi, verticalDpi ); + + mImpl->mEventData->mPlaceholderFont->mDefaultPointSize = ( fontSize * 72.f ) / static_cast< float >( horizontalDpi ); + mImpl->mEventData->mPlaceholderFont->sizeDefined = true; + mImpl->mEventData->mIsPlaceholderPixelSize = true; // Font size flag + break; + } + } + + mImpl->RequestRelayout(); + } +} + +float Controller::GetPlaceholderTextFontSize( FontSizeType type ) const +{ + float value = 0.0f; + if( NULL != mImpl->mEventData ) + { + switch( type ) + { + case POINT_SIZE: + { + if( NULL != mImpl->mEventData->mPlaceholderFont ) + { + value = mImpl->mEventData->mPlaceholderFont->mDefaultPointSize; + } + else + { + // If the placeholder text font size is not set, then return the default font size. + value = GetDefaultFontSize( POINT_SIZE ); + } + break; + } + case PIXEL_SIZE: + { + if( NULL != mImpl->mEventData->mPlaceholderFont ) + { + // Pixel size = Point size * DPI / 72.f + unsigned int horizontalDpi = 0u; + unsigned int verticalDpi = 0u; + TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get(); + fontClient.GetDpi( horizontalDpi, verticalDpi ); + + value = mImpl->mEventData->mPlaceholderFont->mDefaultPointSize * static_cast< float >( horizontalDpi ) / 72.f; + } + else + { + // If the placeholder text font size is not set, then return the default font size. + value = GetDefaultFontSize( PIXEL_SIZE ); + } + break; } } return value; @@ -824,6 +1119,21 @@ const Vector4& Controller::GetShadowColor() const return mImpl->mModel->mVisualModel->GetShadowColor(); } +void Controller::SetShadowBlurRadius( const float& shadowBlurRadius ) +{ + if ( fabsf( GetShadowBlurRadius() - shadowBlurRadius ) > Math::MACHINE_EPSILON_1 ) + { + mImpl->mModel->mVisualModel->SetShadowBlurRadius( shadowBlurRadius ); + + mImpl->RequestRelayout(); + } +} + +const float& Controller::GetShadowBlurRadius() const +{ + return mImpl->mModel->mVisualModel->GetShadowBlurRadius(); +} + void Controller::SetUnderlineColor( const Vector4& color ) { mImpl->mModel->mVisualModel->SetUnderlineColor( color ); @@ -860,6 +1170,30 @@ float Controller::GetUnderlineHeight() const return mImpl->mModel->mVisualModel->GetUnderlineHeight(); } +void Controller::SetOutlineColor( const Vector4& color ) +{ + mImpl->mModel->mVisualModel->SetOutlineColor( color ); + + mImpl->RequestRelayout(); +} + +const Vector4& Controller::GetOutlineColor() const +{ + return mImpl->mModel->mVisualModel->GetOutlineColor(); +} + +void Controller::SetOutlineWidth( float width ) +{ + mImpl->mModel->mVisualModel->SetOutlineWidth( width ); + + mImpl->RequestRelayout(); +} + +float Controller::GetOutlineWidth() const +{ + return mImpl->mModel->mVisualModel->GetOutlineWidth(); +} + void Controller::SetDefaultEmbossProperties( const std::string& embossProperties ) { if( NULL == mImpl->mEmbossDefaults ) @@ -1438,6 +1772,16 @@ void Controller::ShadowSetByString( bool setByString ) mImpl->mShadowSetByString = setByString; } +bool Controller::IsOutlineSetByString() +{ + return mImpl->mOutlineSetByString; +} + +void Controller::OutlineSetByString( bool setByString ) +{ + mImpl->mOutlineSetByString = setByString; +} + bool Controller::IsFontStyleSetByString() { return mImpl->mFontStyleSetByString; @@ -1488,14 +1832,14 @@ Vector3 Controller::GetNaturalSize() mImpl->UpdateModel( onlyOnceOperations ); // Layout the text for the new width. - mImpl->mOperationsPending = static_cast( mImpl->mOperationsPending | LAYOUT ); + mImpl->mOperationsPending = static_cast( mImpl->mOperationsPending | LAYOUT | REORDER ); // Store the actual control's size to restore later. const Size actualControlSize = mImpl->mModel->mVisualModel->mControlSize; DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ), static_cast( onlyOnceOperations | - LAYOUT ), + LAYOUT | REORDER ), naturalSize.GetVectorXY() ); // Do not do again the only once operations. @@ -1541,7 +1885,9 @@ float Controller::GetHeightForWidth( float width ) ProcessModifyEvents(); Size layoutSize; - if( fabsf( width - mImpl->mModel->mVisualModel->mControlSize.width ) > Math::MACHINE_EPSILON_1000 ) + if( fabsf( width - mImpl->mModel->mVisualModel->mControlSize.width ) > Math::MACHINE_EPSILON_1000 || + mImpl->mTextUpdateInfo.mFullRelayoutNeeded || + mImpl->mTextUpdateInfo.mClearAll ) { // Operations that can be done only once until the text changes. const OperationsMask onlyOnceOperations = static_cast( CONVERT_TO_UTF32 | @@ -1599,6 +1945,13 @@ float Controller::GetHeightForWidth( float width ) return layoutSize.height; } +int Controller::GetLineCount( float width ) +{ + GetHeightForWidth( width ); + int numberofLines = mImpl->mModel->GetNumberOfLines(); + return numberofLines; +} + const ModelInterface* const Controller::GetTextModel() const { return mImpl->mModel.Get(); @@ -1645,6 +1998,122 @@ void Controller::GetHiddenInputOption(Property::Map& options ) } } +void Controller::SetPlaceholderProperty( const Property::Map& map ) +{ + const Property::Map::SizeType count = map.Count(); + + for( Property::Map::SizeType position = 0; position < count; ++position ) + { + KeyValuePair keyValue = map.GetKeyValue( position ); + Property::Key& key = keyValue.first; + Property::Value& value = keyValue.second; + + if( key == Toolkit::Text::PlaceHolder::Property::TEXT || key == PLACEHOLDER_TEXT ) + { + std::string text = ""; + value.Get( text ); + SetPlaceholderText( Controller::PLACEHOLDER_TYPE_INACTIVE, text ); + } + else if( key == Toolkit::Text::PlaceHolder::Property::TEXT_FOCUSED || key == PLACEHOLDER_TEXT_FOCUSED ) + { + std::string text = ""; + value.Get( text ); + SetPlaceholderText( Controller::PLACEHOLDER_TYPE_ACTIVE, text ); + } + else if( key == Toolkit::Text::PlaceHolder::Property::COLOR || key == PLACEHOLDER_COLOR ) + { + Vector4 textColor; + value.Get( textColor ); + if( GetPlaceholderTextColor() != textColor ) + { + SetPlaceholderTextColor( textColor ); + } + } + else if( key == Toolkit::Text::PlaceHolder::Property::FONT_FAMILY || key == PLACEHOLDER_FONT_FAMILY ) + { + std::string fontFamily = ""; + value.Get( fontFamily ); + SetPlaceholderFontFamily( fontFamily ); + } + else if( key == Toolkit::Text::PlaceHolder::Property::FONT_STYLE || key == PLACEHOLDER_FONT_STYLE ) + { + SetFontStyleProperty( this, value, Text::FontStyle::PLACEHOLDER ); + } + else if( key == Toolkit::Text::PlaceHolder::Property::POINT_SIZE || key == PLACEHOLDER_POINT_SIZE ) + { + float pointSize; + value.Get( pointSize ); + if( !Equals( GetPlaceholderTextFontSize( Text::Controller::POINT_SIZE ), pointSize ) ) + { + SetPlaceholderTextFontSize( pointSize, Text::Controller::POINT_SIZE ); + } + } + else if( key == Toolkit::Text::PlaceHolder::Property::PIXEL_SIZE || key == PLACEHOLDER_PIXEL_SIZE ) + { + float pixelSize; + value.Get( pixelSize ); + if( !Equals( GetPlaceholderTextFontSize( Text::Controller::PIXEL_SIZE ), pixelSize ) ) + { + SetPlaceholderTextFontSize( pixelSize, Text::Controller::PIXEL_SIZE ); + } + } + else if( key == Toolkit::Text::PlaceHolder::Property::ELLIPSIS || key == PLACEHOLDER_ELLIPSIS ) + { + bool ellipsis; + value.Get( ellipsis ); + SetPlaceholderTextElideEnabled( ellipsis ); + } + } +} + +void Controller::GetPlaceholderProperty( Property::Map& map ) +{ + if( NULL != mImpl->mEventData ) + { + if( !mImpl->mEventData->mPlaceholderTextActive.empty() ) + { + map[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = mImpl->mEventData->mPlaceholderTextActive; + } + if( !mImpl->mEventData->mPlaceholderTextInactive.empty() ) + { + map[ Text::PlaceHolder::Property::TEXT ] = mImpl->mEventData->mPlaceholderTextInactive; + } + + map[ Text::PlaceHolder::Property::COLOR ] = mImpl->mEventData->mPlaceholderTextColor; + map[ Text::PlaceHolder::Property::FONT_FAMILY ] = GetPlaceholderFontFamily(); + + Property::Value fontStyleMapGet; + GetFontStyleProperty( this, fontStyleMapGet, Text::FontStyle::PLACEHOLDER ); + map[ Text::PlaceHolder::Property::FONT_STYLE ] = fontStyleMapGet; + + // Choose font size : POINT_SIZE or PIXEL_SIZE + if( !mImpl->mEventData->mIsPlaceholderPixelSize ) + { + map[ Text::PlaceHolder::Property::POINT_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::POINT_SIZE ); + } + else + { + map[ Text::PlaceHolder::Property::PIXEL_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::PIXEL_SIZE ); + } + + if( mImpl->mEventData->mPlaceholderEllipsisFlag ) + { + map[ Text::PlaceHolder::Property::ELLIPSIS ] = IsPlaceholderTextElideEnabled(); + } + } +} + +Toolkit::DevelText::TextDirection::Type Controller::GetTextDirection() +{ + const LineRun* const firstline = mImpl->mModel->mVisualModel->mLines.Begin(); + if ( firstline && firstline->direction ) + { + return Toolkit::DevelText::TextDirection::RIGHT_TO_LEFT; + } + + return Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT; +} + // public : Relayout. Controller::UpdateTextType Controller::Relayout( const Size& size ) @@ -1699,6 +2168,20 @@ Controller::UpdateTextType Controller::Relayout( const Size& size ) COLOR ); } + // Set the update info to elide the text. + if( mImpl->mModel->mElideEnabled || + ( ( NULL != mImpl->mEventData ) && mImpl->mEventData->mIsPlaceholderElideEnabled ) ) + { + // Update Text layout for applying elided + mImpl->mOperationsPending = static_cast( mImpl->mOperationsPending | + ALIGN | + LAYOUT | + UPDATE_LAYOUT_SIZE | + REORDER ); + mImpl->mTextUpdateInfo.mFullRelayoutNeeded = true; + mImpl->mTextUpdateInfo.mCharacterIndex = 0u; + } + // Make sure the model is up-to-date before layouting. ProcessModifyEvents(); bool updated = mImpl->UpdateModel( mImpl->mOperationsPending ); @@ -1854,6 +2337,7 @@ bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent ) { int keyCode = keyEvent.keyCode; const std::string& keyString = keyEvent.keyPressed; + const std::string keyName = keyEvent.keyPressedName; const bool isNullKey = ( 0 == keyCode ) && ( keyString.empty() ); @@ -1862,14 +2346,12 @@ bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent ) { // In some platforms arrive key events with no key code. // Do nothing. + return false; } - else if( Dali::DALI_KEY_ESCAPE == keyCode ) + else if( Dali::DALI_KEY_ESCAPE == keyCode || Dali::DALI_KEY_BACK == keyCode || Dali::DALI_KEY_SEARCH == keyCode ) { - // Escape key is a special case which causes focus loss - KeyboardFocusLostEvent(); - - // Will request for relayout. - relayoutNeeded = true; + // Do nothing + return false; } else if( ( Dali::DALI_KEY_CURSOR_LEFT == keyCode ) || ( Dali::DALI_KEY_CURSOR_RIGHT == keyCode ) || @@ -1901,14 +2383,47 @@ bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent ) mImpl->mEventData->mCheckScrollAmount = true; Event event( Event::CURSOR_KEY_EVENT ); event.p1.mInt = keyCode; + event.p2.mBool = keyEvent.IsShiftModifier(); mImpl->mEventData->mEventQueue.push_back( event ); // Will request for relayout. relayoutNeeded = true; } - else if( Dali::DALI_KEY_BACKSPACE == keyCode ) + else if ( Dali::DevelKey::DALI_KEY_CONTROL_LEFT == keyCode || Dali::DevelKey::DALI_KEY_CONTROL_RIGHT == keyCode ) { - textChanged = BackspaceKeyEvent(); + // Left or Right Control key event is received before Ctrl-C/V/X key event is received + // If not handle it here, any selected text will be deleted + + // Do nothing + return false; + } + else if ( keyEvent.IsCtrlModifier() ) + { + bool consumed = false; + if (keyName == KEY_C_NAME) + { + // Ctrl-C to copy the selected text + TextPopupButtonTouched( Toolkit::TextSelectionPopup::COPY ); + consumed = true; + } + else if (keyName == KEY_V_NAME) + { + // Ctrl-V to paste the copied text + TextPopupButtonTouched( Toolkit::TextSelectionPopup::PASTE ); + consumed = true; + } + else if (keyName == KEY_X_NAME) + { + // Ctrl-X to cut the selected text + TextPopupButtonTouched( Toolkit::TextSelectionPopup::CUT ); + consumed = true; + } + return consumed; + } + else if( ( Dali::DALI_KEY_BACKSPACE == keyCode ) || + ( Dali::DevelKey::DALI_KEY_DELETE == keyCode ) ) + { + textChanged = DeleteEvent( keyCode ); // Will request for relayout. relayoutNeeded = true; @@ -1931,11 +2446,13 @@ bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent ) // and a character is typed after the type of a upper case latin character. // Do nothing. + return false; } else if( ( Dali::DALI_KEY_VOLUME_UP == keyCode ) || ( Dali::DALI_KEY_VOLUME_DOWN == keyCode ) ) { // This branch avoids calling the InsertText() method of the 'else' branch which can delete selected text. // Do nothing. + return false; } else { @@ -2220,7 +2737,17 @@ ImfManager::ImfCallbackData Controller::OnImfEvent( ImfManager& imfManager, cons if( retrieveText ) { - mImpl->GetText( numberOfWhiteSpaces, text ); + if( !mImpl->IsShowingPlaceholderText() ) + { + // Retrieves the normal text string. + mImpl->GetText( numberOfWhiteSpaces, text ); + } + else + { + // When the current text is Placeholder Text, the surrounding text should be empty string. + // It means DALi should send empty string ("") to IME. + text = ""; + } } ImfManager::ImfCallbackData callbackData( ( retrieveText || retrieveCursor ), cursorPosition, text, false ); @@ -2609,8 +3136,18 @@ void Controller::InsertText( const std::string& text, Controller::InsertType typ } // Mark the first paragraph to be updated. - mImpl->mTextUpdateInfo.mCharacterIndex = std::min( cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex ); - mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd += maxSizeOfNewText; + if( Layout::Engine::SINGLE_LINE_BOX == mImpl->mLayoutEngine.GetLayout() ) + { + mImpl->mTextUpdateInfo.mCharacterIndex = 0; + mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters; + mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = numberOfCharactersInModel + maxSizeOfNewText; + mImpl->mTextUpdateInfo.mClearAll = true; + } + else + { + mImpl->mTextUpdateInfo.mCharacterIndex = std::min( cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex ); + mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd += maxSizeOfNewText; + } // Update the cursor index. cursorIndex += maxSizeOfNewText; @@ -2708,8 +3245,18 @@ bool Controller::RemoveText( int cursorOffset, ( ( cursorIndex + numberOfCharacters ) <= mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters ) ) { // Mark the paragraphs to be updated. - mImpl->mTextUpdateInfo.mCharacterIndex = std::min( cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex ); - mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove += numberOfCharacters; + if( Layout::Engine::SINGLE_LINE_BOX == mImpl->mLayoutEngine.GetLayout() ) + { + mImpl->mTextUpdateInfo.mCharacterIndex = 0; + mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters; + mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters - numberOfCharacters; + mImpl->mTextUpdateInfo.mClearAll = true; + } + else + { + mImpl->mTextUpdateInfo.mCharacterIndex = std::min( cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex ); + mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove += numberOfCharacters; + } // Update the input style and remove the text's style before removing the text. @@ -2833,6 +3380,7 @@ bool Controller::DoRelayout( const Size& size, const Vector& glyphsToCharactersMap = mImpl->mModel->mVisualModel->mGlyphsToCharacters; const Vector& charactersPerGlyph = mImpl->mModel->mVisualModel->mCharactersPerGlyph; const Character* const textBuffer = mImpl->mModel->mLogicalModel->mText.Begin(); + float outlineWidth = mImpl->mModel->GetOutlineWidth(); // Set the layout parameters. Layout::Parameters layoutParameters( size, @@ -2846,7 +3394,9 @@ bool Controller::DoRelayout( const Size& size, charactersToGlyphBuffer, glyphsPerCharacterBuffer, totalNumberOfGlyphs, - mImpl->mModel->mHorizontalAlignment ); + mImpl->mModel->mHorizontalAlignment, + mImpl->mModel->mLineWrapMode, + outlineWidth ); // Resize the vector of positions to have the same size than the vector of glyphs. Vector& glyphPositions = mImpl->mModel->mVisualModel->mGlyphPositions; @@ -2862,13 +3412,35 @@ bool Controller::DoRelayout( const Size& size, layoutParameters.startLineIndex = mImpl->mTextUpdateInfo.mStartLineIndex; layoutParameters.estimatedNumberOfLines = mImpl->mTextUpdateInfo.mEstimatedNumberOfLines; + // Update the ellipsis + bool elideTextEnabled = mImpl->mModel->mElideEnabled; + + if( NULL != mImpl->mEventData ) + { + if( mImpl->mEventData->mPlaceholderEllipsisFlag && mImpl->IsShowingPlaceholderText() ) + { + elideTextEnabled = mImpl->mEventData->mIsPlaceholderElideEnabled; + } + else if( EventData::INACTIVE != mImpl->mEventData->mState ) + { + // Disable ellipsis when editing + elideTextEnabled = false; + } + + // Reset the scroll position in inactive state + if( elideTextEnabled && ( mImpl->mEventData->mState == EventData::INACTIVE ) ) + { + ResetScrollPosition(); + } + } + // Update the visual model. Size newLayoutSize; viewUpdated = mImpl->mLayoutEngine.LayoutText( layoutParameters, glyphPositions, mImpl->mModel->mVisualModel->mLines, newLayoutSize, - mImpl->mModel->mElideEnabled ); + elideTextEnabled ); viewUpdated = viewUpdated || ( newLayoutSize != layoutSize ); @@ -2967,17 +3539,17 @@ void Controller::CalculateVerticalOffset( const Size& controlSize ) switch( mImpl->mModel->mVerticalAlignment ) { - case Layout::VERTICAL_ALIGN_TOP: + case VerticalAlignment::TOP: { mImpl->mModel->mScrollPosition.y = 0.f; break; } - case Layout::VERTICAL_ALIGN_CENTER: + case VerticalAlignment::CENTER: { mImpl->mModel->mScrollPosition.y = floorf( 0.5f * ( controlSize.height - layoutSize.height ) ); // try to avoid pixel alignment. break; } - case Layout::VERTICAL_ALIGN_BOTTOM: + case VerticalAlignment::BOTTOM: { mImpl->mModel->mScrollPosition.y = controlSize.height - layoutSize.height; break; @@ -3029,6 +3601,10 @@ void Controller::ProcessModifyEvents() { // When the text is being modified, delay cursor blinking mImpl->mEventData->mDecorator->DelayCursorBlink(); + + // Update selection position after modifying the text + mImpl->mEventData->mLeftSelectionPosition = mImpl->mEventData->mPrimaryCursorPosition; + mImpl->mEventData->mRightSelectionPosition = mImpl->mEventData->mPrimaryCursorPosition; } // Discard temporary text @@ -3106,9 +3682,9 @@ void Controller::SelectEvent( float x, float y, bool selectAll ) } } -bool Controller::BackspaceKeyEvent() +bool Controller::DeleteEvent( int keyCode ) { - DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p DALI_KEY_BACKSPACE\n", this ); + DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p KeyCode : %d \n", this, keyCode ); bool removed = false; @@ -3124,13 +3700,20 @@ bool Controller::BackspaceKeyEvent() { removed = RemoveSelectedText(); } - else if( mImpl->mEventData->mPrimaryCursorPosition > 0 ) + else if( ( mImpl->mEventData->mPrimaryCursorPosition > 0 ) && ( keyCode == Dali::DALI_KEY_BACKSPACE) ) { // Remove the character before the current cursor position removed = RemoveText( -1, 1, UPDATE_INPUT_STYLE ); } + else if( ( mImpl->mEventData->mPrimaryCursorPosition >= 0 ) && ( keyCode == Dali::DevelKey::DALI_KEY_DELETE ) ) + { + // Remove the character after the current cursor position + removed = RemoveText( 0, + 1, + UPDATE_INPUT_STYLE ); + } if( removed ) { @@ -3195,7 +3778,7 @@ void Controller::ShowPlaceholderText() const char* text( NULL ); size_t size( 0 ); - // TODO - Switch placeholder text styles when changing state + // TODO - Switch Placeholder text when changing state if( ( EventData::INACTIVE != mImpl->mEventData->mState ) && ( 0u != mImpl->mEventData->mPlaceholderTextActive.c_str() ) ) { @@ -3301,6 +3884,16 @@ void Controller::ResetScrollPosition() } } +void Controller::SetControlInterface( ControlInterface* controlInterface ) +{ + mImpl->mControlInterface = controlInterface; +} + +bool Controller::ShouldClearFocusOnEscape() const +{ + return mImpl->mShouldClearFocusOnEscape; +} + // private : Private contructors & copy operator. Controller::Controller()