#include <dali/public-api/adaptor-framework/key.h>
#include <dali/integration-api/debug.h>
#include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
+#include <dali/devel-api/text-abstraction/font-client.h>
// INTERNAL INCLUDES
#include <dali-toolkit/internal/text/bidirectional-support.h>
#include <dali-toolkit/internal/text/character-set-conversion.h>
#include <dali-toolkit/internal/text/layouts/layout-parameters.h>
#include <dali-toolkit/internal/text/markup-processor.h>
+#include <dali-toolkit/internal/text/multi-language-support.h>
#include <dali-toolkit/internal/text/text-controller-impl.h>
#include <dali-toolkit/internal/text/text-editable-control-interface.h>
+#include <dali-toolkit/internal/text/text-font-style.h>
namespace
{
const std::string EMPTY_STRING("");
+const char * const PLACEHOLDER_TEXT = "placeholderText";
+const char * const PLACEHOLDER_TEXT_FOCUSED = "placeholderTextFocused";
+const char * const PLACEHOLDER_COLOR = "placeholderColor";
+const char * const PLACEHOLDER_FONT_FAMILY = "placeholderFontFamily";
+const char * const PLACEHOLDER_FONT_STYLE = "placeholderFontStyle";
+const char * const PLACEHOLDER_POINT_SIZE = "placeholderPointSize";
+const char * const PLACEHOLDER_PIXEL_SIZE = "placeholderPixelSize";
+
float ConvertToEven( float value )
{
int intValue(static_cast<int>( value ));
return mImpl->mModel->mVerticalAlignment;
}
+void Controller::SetLineWrapMode( Layout::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<OperationsMask>( 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();
+ }
+}
+
+Layout::LineWrap::Mode Controller::GetLineWrapMode() const
+{
+ return mImpl->mModel->mLineWrapMode;
+}
+
void Controller::SetTextElideEnabled( bool enabled )
{
mImpl->mModel->mElideEnabled = enabled;
return mImpl->mModel->mElideEnabled;
}
+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 )
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 )
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 )
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 )
return TextAbstraction::FontSlant::NORMAL;
}
-void Controller::SetDefaultPointSize( float pointSize )
+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 )
{
mImpl->mFontDefaults = new FontDefaults();
}
- mImpl->mFontDefaults->mDefaultPointSize = pointSize;
- mImpl->mFontDefaults->sizeDefined = true;
+ switch( type )
+ {
+ case POINT_SIZE:
+ {
+ mImpl->mFontDefaults->mDefaultPointSize = fontSize;
+ mImpl->mFontDefaults->sizeDefined = true;
+ break;
+ }
+ case PIXEL_SIZE:
+ {
+ // 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.f ) / static_cast< float >( horizontalDpi );
+ mImpl->mFontDefaults->sizeDefined = true;
+ break;
+ }
+ }
// Clear the font-specific data
ClearFontData();
mImpl->RequestRelayout();
}
-float Controller::GetDefaultPointSize() const
+float Controller::GetDefaultFontSize( FontSizeType type ) const
{
+ float value = 0.0f;
if( NULL != mImpl->mFontDefaults )
{
- return mImpl->mFontDefaults->mDefaultPointSize;
+ switch( type )
+ {
+ case POINT_SIZE:
+ {
+ value = mImpl->mFontDefaults->mDefaultPointSize;
+ break;
+ }
+ case PIXEL_SIZE:
+ {
+ // 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 * static_cast< float >( horizontalDpi ) / 72.f;
+ break;
+ }
+ }
+ return value;
}
- return 0.0f;
+ 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;
+ }
+ case PIXEL_SIZE:
+ {
+ // 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;
+ }
+
+ return value;
}
void Controller::SetDefaultColor( const Vector4& color )
}
// Return the default font's point size if there is no EventData.
- return GetDefaultPointSize();
+ return GetDefaultFontSize( Text::Controller::POINT_SIZE );
}
void Controller::SetInputLineSpacing( float lineSpacing )
return action;
}
+bool Controller::IsUnderlineSetByString()
+{
+ return mImpl->mUnderlineSetByString;
+}
+
+void Controller::UnderlineSetByString( bool setByString )
+{
+ mImpl->mUnderlineSetByString = setByString;
+}
+
+bool Controller::IsShadowSetByString()
+{
+ return mImpl->mShadowSetByString;
+}
+
+void Controller::ShadowSetByString( bool setByString )
+{
+ mImpl->mShadowSetByString = setByString;
+}
+
+bool Controller::IsFontStyleSetByString()
+{
+ return mImpl->mFontStyleSetByString;
+}
+
+void Controller::FontStyleSetByString( bool setByString )
+{
+ mImpl->mFontStyleSetByString = setByString;
+}
+
// public : Queries & retrieves.
Layout::Engine& Controller::GetLayoutEngine()
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<OperationsMask>( CONVERT_TO_UTF32 |
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();
return isScrolled;
}
+void Controller::SetHiddenInputOption(const Property::Map& options )
+{
+ if( NULL == mImpl->mHiddenInput )
+ {
+ mImpl->mHiddenInput = new HiddenText( this );
+ }
+ mImpl->mHiddenInput->SetProperties(options);
+}
+
+void Controller::GetHiddenInputOption(Property::Map& options )
+{
+ if( NULL != mImpl->mHiddenInput )
+ {
+ mImpl->mHiddenInput->GetProperties(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 == PLACEHOLDER_TEXT )
+ {
+ std::string text = "";
+ value.Get( text );
+ SetPlaceholderText( Controller::PLACEHOLDER_TYPE_INACTIVE, text );
+ }
+ else if( key == PLACEHOLDER_TEXT_FOCUSED )
+ {
+ std::string text = "";
+ value.Get( text );
+ SetPlaceholderText( Controller::PLACEHOLDER_TYPE_ACTIVE, text );
+ }
+ else if( key == PLACEHOLDER_COLOR )
+ {
+ Vector4 textColor;
+ value.Get( textColor );
+ if( GetPlaceholderTextColor() != textColor )
+ {
+ SetPlaceholderTextColor( textColor );
+ }
+ }
+ else if( key == PLACEHOLDER_FONT_FAMILY )
+ {
+ std::string fontFamily = "";
+ value.Get( fontFamily );
+ SetPlaceholderFontFamily( fontFamily );
+ }
+ else if( key == PLACEHOLDER_FONT_STYLE )
+ {
+ SetFontStyleProperty( this, value, Text::FontStyle::PLACEHOLDER );
+ }
+ else if( 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 == PLACEHOLDER_PIXEL_SIZE )
+ {
+ float pixelSize;
+ value.Get( pixelSize );
+ if( !Equals( GetPlaceholderTextFontSize( Text::Controller::PIXEL_SIZE ), pixelSize ) )
+ {
+ SetPlaceholderTextFontSize( pixelSize, Text::Controller::PIXEL_SIZE );
+ }
+ }
+ }
+}
+
+void Controller::GetPlaceholderProperty( Property::Map& map )
+{
+ if( NULL != mImpl->mEventData )
+ {
+ if( !mImpl->mEventData->mPlaceholderTextActive.empty() )
+ {
+ map[ PLACEHOLDER_TEXT_FOCUSED ] = mImpl->mEventData->mPlaceholderTextActive;
+ }
+ if( !mImpl->mEventData->mPlaceholderTextInactive.empty() )
+ {
+ map[ PLACEHOLDER_TEXT ] = mImpl->mEventData->mPlaceholderTextInactive;
+ }
+
+ map[ PLACEHOLDER_COLOR ] = mImpl->mEventData->mPlaceholderTextColor;
+ map[ PLACEHOLDER_FONT_FAMILY ] = GetPlaceholderFontFamily();
+
+ Property::Value fontStyleMapGet;
+ GetFontStyleProperty( this, fontStyleMapGet, Text::FontStyle::PLACEHOLDER );
+ map[ PLACEHOLDER_FONT_STYLE ] = fontStyleMapGet;
+
+ // Choose font size : POINT_SIZE or PIXEL_SIZE
+ if( !mImpl->mEventData->mIsPlaceholderPixelSize )
+ {
+ map[ PLACEHOLDER_POINT_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::POINT_SIZE );
+ }
+ else
+ {
+ map[ PLACEHOLDER_PIXEL_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::PIXEL_SIZE );
+ }
+ }
+}
+
// public : Relayout.
Controller::UpdateTextType Controller::Relayout( const Size& size )
{
// In some platforms arrive key events with no key code.
// Do nothing.
+ return false;
}
else if( Dali::DALI_KEY_ESCAPE == keyCode )
{
// 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
{
retrieveCursor = true;
break;
}
+ case ImfManager::PRIVATECOMMAND:
+ {
+ // PRIVATECOMMAND event is just for getting the private command message
+ retrieveText = true;
+ retrieveCursor = true;
+ break;
+ }
case ImfManager::VOID:
{
// do nothing
}
}
+void Controller::DisplayTimeExpired()
+{
+ mImpl->mEventData->mUpdateCursorPosition = true;
+ // Apply modifications to the model
+ mImpl->mOperationsPending = ALL_OPERATIONS;
+
+ mImpl->RequestRelayout();
+}
+
// private : Update.
void Controller::InsertText( const std::string& text, Controller::InsertType type )
}
// 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;
Vector<Character>& currentText = mImpl->mModel->mLogicalModel->mText;
CharacterIndex& oldCursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
- CharacterIndex cursorIndex = oldCursorIndex;
+ CharacterIndex cursorIndex = 0;
// Validate the cursor position & number of characters
- if( static_cast< CharacterIndex >( std::abs( cursorOffset ) ) <= cursorIndex )
+ if( ( static_cast< int >( mImpl->mEventData->mPrimaryCursorPosition ) + cursorOffset ) >= 0 )
{
- cursorIndex = oldCursorIndex + cursorOffset;
+ cursorIndex = mImpl->mEventData->mPrimaryCursorPosition + cursorOffset;
}
if( ( cursorIndex + numberOfCharacters ) > currentText.Count() )
( ( 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.
charactersToGlyphBuffer,
glyphsPerCharacterBuffer,
totalNumberOfGlyphs,
- mImpl->mModel->mHorizontalAlignment );
+ mImpl->mModel->mHorizontalAlignment,
+ mImpl->mModel->mLineWrapMode );
// Resize the vector of positions to have the same size than the vector of glyphs.
Vector<Vector2>& glyphPositions = mImpl->mModel->mVisualModel->mGlyphPositions;
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() ) )
{
projects / platform / core / uifw / dali-toolkit.git / blobdiff