#include <dali-toolkit/internal/text/bidirectional-support.h>
#include <dali-toolkit/internal/text/character-set-conversion.h>
#include <dali-toolkit/internal/text/color-segmentation.h>
+#include <dali-toolkit/internal/text/glyph-metrics-helper.h>
#include <dali-toolkit/internal/text/multi-language-support.h>
#include <dali-toolkit/internal/text/segmentation.h>
#include <dali-toolkit/internal/text/shaper.h>
Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
#endif
-/**
- * @brief Some characters can be shaped in more than one glyph.
- * This struct is used to retrieve metrics from these group of glyphs.
- */
-struct GlyphMetrics
-{
- GlyphMetrics()
- : fontHeight( 0.f ),
- advance( 0.f ),
- ascender( 0.f ),
- xBearing( 0.f )
- {}
-
- ~GlyphMetrics()
- {}
-
- float fontHeight; ///< The font's height of that glyphs.
- float advance; ///< The sum of all the advances of all the glyphs.
- float ascender; ///< The font's ascender.
- float xBearing; ///< The x bearing of the first glyph.
-};
-
} // namespace
namespace Dali
namespace Text
{
-/**
- * @brief Get some glyph's metrics of a group of glyphs formed as a result of shaping one character.
- *
- * @param[in] glyphIndex The index to the first glyph.
- * @param[in] numberOfGlyphs The number of glyphs.
- * @param[out] glyphMetrics Some glyph metrics (font height, advance, ascender and x bearing).
- * @param[in] visualModel The visual model.
- * @param[in] metrics Used to access metrics from FontClient.
- */
-void GetGlyphsMetrics( GlyphIndex glyphIndex,
- Length numberOfGlyphs,
- GlyphMetrics& glyphMetrics,
- VisualModelPtr& visualModel,
- MetricsPtr& metrics )
-{
- const GlyphInfo* glyphsBuffer = visualModel->mGlyphs.Begin();
-
- const GlyphInfo& firstGlyph = *( glyphsBuffer + glyphIndex );
-
- Text::FontMetrics fontMetrics;
- metrics->GetFontMetrics( firstGlyph.fontId, fontMetrics );
-
- glyphMetrics.fontHeight = fontMetrics.height;
- glyphMetrics.advance = firstGlyph.advance;
- glyphMetrics.ascender = fontMetrics.ascender;
- glyphMetrics.xBearing = firstGlyph.xBearing;
-
- for( unsigned int i = 1u; i < numberOfGlyphs; ++i )
- {
- const GlyphInfo& glyphInfo = *( glyphsBuffer + glyphIndex + i );
-
- glyphMetrics.advance += glyphInfo.advance;
- }
-}
-
EventData::EventData( DecoratorPtr decorator )
: mDecorator( decorator ),
mImfManager(),
GetCursorPosition( mEventData->mPrimaryCursorPosition,
cursorInfo );
- if( mEventData->mScrollAfterUpdatePosition )
+ // Scroll first the text after delete ...
+ if( mEventData->mScrollAfterDelete )
{
- ScrollToMakePositionVisible( cursorInfo.primaryPosition );
- mEventData->mScrollAfterUpdatePosition = false;
+ ScrollTextToMatchCursor( cursorInfo );
}
- else if( mEventData->mScrollAfterDelete )
+
+ // ... then, text can be scrolled to make the cursor visible.
+ if( mEventData->mScrollAfterUpdatePosition )
{
- ScrollTextToMatchCursor( cursorInfo );
- mEventData->mScrollAfterDelete = false;
+ ScrollToMakePositionVisible( cursorInfo.primaryPosition );
}
+ mEventData->mScrollAfterUpdatePosition = false;
+ mEventData->mScrollAfterDelete = false;
UpdateCursorPosition( cursorInfo );
}
else
{
- CharacterIndex lastIndex = 0u;
+ Length numberOfCharactersToUpdate = 0u;
if( mTextUpdateInfo.mFullRelayoutNeeded )
{
- lastIndex = mTextUpdateInfo.mPreviousNumberOfCharacters;
+ numberOfCharactersToUpdate = mTextUpdateInfo.mPreviousNumberOfCharacters;
}
else
{
- lastIndex = ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) ? mTextUpdateInfo.mNumberOfCharactersToRemove : 1u;
+ numberOfCharactersToUpdate = ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) ? mTextUpdateInfo.mNumberOfCharactersToRemove : 1u;
}
mLogicalModel->FindParagraphs( mTextUpdateInfo.mCharacterIndex,
- lastIndex,
+ numberOfCharactersToUpdate,
paragraphsToBeUpdated );
}
numberOfCharacters = lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters - mTextUpdateInfo.mParagraphCharacterIndex;
}
}
+
mTextUpdateInfo.mRequestedNumberOfCharacters = numberOfCharacters + mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
mTextUpdateInfo.mStartGlyphIndex = *( mVisualModel->mCharactersToGlyph.Begin() + mTextUpdateInfo.mParagraphCharacterIndex );
}
void Controller::Impl::ClearFullModelData( OperationsMask operations )
{
- if( GET_LINE_BREAKS & operations )
+ if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
{
mLogicalModel->mLineBreakInfo.Clear();
mLogicalModel->mParagraphInfo.Clear();
}
- if( GET_WORD_BREAKS & operations )
+ if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) )
{
mLogicalModel->mLineBreakInfo.Clear();
}
- if( GET_SCRIPTS & operations )
+ if( NO_OPERATION != ( GET_SCRIPTS & operations ) )
{
mLogicalModel->mScriptRuns.Clear();
}
- if( VALIDATE_FONTS & operations )
+ if( NO_OPERATION != ( VALIDATE_FONTS & operations ) )
{
mLogicalModel->mFontRuns.Clear();
}
if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() )
{
- if( BIDI_INFO & operations )
+ if( NO_OPERATION != ( BIDI_INFO & operations ) )
{
mLogicalModel->mBidirectionalParagraphInfo.Clear();
mLogicalModel->mCharacterDirections.Clear();
}
- if( REORDER & operations )
+ if( NO_OPERATION != ( REORDER & operations ) )
{
// Free the allocated memory used to store the conversion table in the bidirectional line info run.
for( Vector<BidirectionalLineInfoRun>::Iterator it = mLogicalModel->mBidirectionalLineInfo.Begin(),
bidiLineInfo.visualToLogicalMap = NULL;
}
mLogicalModel->mBidirectionalLineInfo.Clear();
-
- mLogicalModel->mLogicalToVisualMap.Clear();
- mLogicalModel->mVisualToLogicalMap.Clear();
}
}
- if( SHAPE_TEXT & operations )
+ if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
{
mVisualModel->mGlyphs.Clear();
mVisualModel->mGlyphsToCharacters.Clear();
mVisualModel->mGlyphPositions.Clear();
}
- if( LAYOUT & operations )
+ if( NO_OPERATION != ( LAYOUT & operations ) )
{
mVisualModel->mLines.Clear();
}
+
+ if( NO_OPERATION != ( COLOR & operations ) )
+ {
+ mVisualModel->mColorIndices.Clear();
+ }
}
void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations )
{
const CharacterIndex endIndexPlusOne = endIndex + 1u;
- if( GET_LINE_BREAKS & operations )
+ if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
{
// Clear the line break info.
LineBreakInfo* lineBreakInfoBuffer = mLogicalModel->mLineBreakInfo.Begin();
mLogicalModel->mParagraphInfo );
}
- if( GET_WORD_BREAKS & operations )
+ if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) )
{
// Clear the word break info.
WordBreakInfo* wordBreakInfoBuffer = mLogicalModel->mWordBreakInfo.Begin();
wordBreakInfoBuffer + endIndexPlusOne );
}
- if( GET_SCRIPTS & operations )
+ if( NO_OPERATION != ( GET_SCRIPTS & operations ) )
{
// Clear the scripts.
ClearCharacterRuns( startIndex,
mLogicalModel->mScriptRuns );
}
- if( VALIDATE_FONTS & operations )
+ if( NO_OPERATION != ( VALIDATE_FONTS & operations ) )
{
// Clear the fonts.
ClearCharacterRuns( startIndex,
if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() )
{
- if( BIDI_INFO & operations )
+ if( NO_OPERATION != ( BIDI_INFO & operations ) )
{
// Clear the bidirectional paragraph info.
ClearCharacterRuns( startIndex,
characterDirectionsBuffer + endIndexPlusOne );
}
- if( REORDER & operations )
+ if( NO_OPERATION != ( REORDER & operations ) )
{
uint32_t startRemoveIndex = mLogicalModel->mBidirectionalLineInfo.Count();
uint32_t endRemoveIndex = startRemoveIndex;
mLogicalModel->mBidirectionalLineInfo.Erase( bidirectionalLineInfoBuffer + startRemoveIndex,
bidirectionalLineInfoBuffer + endRemoveIndex );
-
- // Clear the logical to visual and the visual to logical conversion tables.
- CharacterIndex* logicalToVisualMapBuffer = mLogicalModel->mLogicalToVisualMap.Begin();
- mLogicalModel->mLogicalToVisualMap.Erase( logicalToVisualMapBuffer + startIndex,
- logicalToVisualMapBuffer + endIndexPlusOne );
-
- CharacterIndex* visualToLogicalMapBuffer = mLogicalModel->mVisualToLogicalMap.Begin();
- mLogicalModel->mVisualToLogicalMap.Erase( visualToLogicalMapBuffer + startIndex,
- visualToLogicalMapBuffer + endIndexPlusOne );
}
}
}
const CharacterIndex endIndexPlusOne = endIndex + 1u;
const Length numberOfCharactersRemoved = endIndexPlusOne - startIndex;
- const bool clearShape = SHAPE_TEXT & operations;
- const bool clearLayout = LAYOUT & operations;
+ // Convert the character index to glyph index before deleting the character to glyph and the glyphs per character buffers.
+ GlyphIndex* charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin();
+ Length* glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin();
- if( clearShape || clearLayout )
- {
- // Convert the character index to glyph index before deleting the character to glyph and the glyphs per character buffers.
- GlyphIndex* charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin();
- Length* glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin();
-
- const GlyphIndex endGlyphIndex = *( charactersToGlyphBuffer + endIndex );
- const GlyphIndex endGlyphIndexPlusOne = endGlyphIndex + *( glyphsPerCharacterBuffer + endIndex );
- const Length numberOfGlyphsRemoved = endGlyphIndexPlusOne - mTextUpdateInfo.mStartGlyphIndex;
+ const GlyphIndex endGlyphIndexPlusOne = *( charactersToGlyphBuffer + endIndex ) + *( glyphsPerCharacterBuffer + endIndex );
+ const Length numberOfGlyphsRemoved = endGlyphIndexPlusOne - mTextUpdateInfo.mStartGlyphIndex;
- if( clearShape )
+ if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
+ {
+ // Update the character to glyph indices.
+ for( Vector<GlyphIndex>::Iterator it = charactersToGlyphBuffer + endIndexPlusOne,
+ endIt = charactersToGlyphBuffer + mVisualModel->mCharactersToGlyph.Count();
+ it != endIt;
+ ++it )
{
- // Update the character to glyph indices.
- for( Vector<GlyphIndex>::Iterator it = charactersToGlyphBuffer + endIndexPlusOne,
- endIt = charactersToGlyphBuffer + mVisualModel->mCharactersToGlyph.Count();
- it != endIt;
- ++it )
- {
- CharacterIndex& index = *it;
- index -= numberOfGlyphsRemoved;
- }
+ CharacterIndex& index = *it;
+ index -= numberOfGlyphsRemoved;
+ }
- // Clear the character to glyph conversion table.
- mVisualModel->mCharactersToGlyph.Erase( charactersToGlyphBuffer + startIndex,
- charactersToGlyphBuffer + endIndexPlusOne );
+ // Clear the character to glyph conversion table.
+ mVisualModel->mCharactersToGlyph.Erase( charactersToGlyphBuffer + startIndex,
+ charactersToGlyphBuffer + endIndexPlusOne );
- // Clear the glyphs per character table.
- mVisualModel->mGlyphsPerCharacter.Erase( glyphsPerCharacterBuffer + startIndex,
- glyphsPerCharacterBuffer + endIndexPlusOne );
+ // Clear the glyphs per character table.
+ mVisualModel->mGlyphsPerCharacter.Erase( glyphsPerCharacterBuffer + startIndex,
+ glyphsPerCharacterBuffer + endIndexPlusOne );
- // Clear the glyphs buffer.
- GlyphInfo* glyphsBuffer = mVisualModel->mGlyphs.Begin();
- mVisualModel->mGlyphs.Erase( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex,
- glyphsBuffer + endGlyphIndexPlusOne );
+ // Clear the glyphs buffer.
+ GlyphInfo* glyphsBuffer = mVisualModel->mGlyphs.Begin();
+ mVisualModel->mGlyphs.Erase( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex,
+ glyphsBuffer + endGlyphIndexPlusOne );
- CharacterIndex* glyphsToCharactersBuffer = mVisualModel->mGlyphsToCharacters.Begin();
+ CharacterIndex* glyphsToCharactersBuffer = mVisualModel->mGlyphsToCharacters.Begin();
- // Update the glyph to character indices.
- for( Vector<CharacterIndex>::Iterator it = glyphsToCharactersBuffer + endGlyphIndexPlusOne,
- endIt = glyphsToCharactersBuffer + mVisualModel->mGlyphsToCharacters.Count();
- it != endIt;
- ++it )
- {
- CharacterIndex& index = *it;
- index -= numberOfCharactersRemoved;
- }
+ // Update the glyph to character indices.
+ for( Vector<CharacterIndex>::Iterator it = glyphsToCharactersBuffer + endGlyphIndexPlusOne,
+ endIt = glyphsToCharactersBuffer + mVisualModel->mGlyphsToCharacters.Count();
+ it != endIt;
+ ++it )
+ {
+ CharacterIndex& index = *it;
+ index -= numberOfCharactersRemoved;
+ }
- // Clear the glyphs to characters buffer.
- mVisualModel->mGlyphsToCharacters.Erase( glyphsToCharactersBuffer + mTextUpdateInfo.mStartGlyphIndex,
- glyphsToCharactersBuffer + endGlyphIndexPlusOne );
+ // Clear the glyphs to characters buffer.
+ mVisualModel->mGlyphsToCharacters.Erase( glyphsToCharactersBuffer + mTextUpdateInfo.mStartGlyphIndex,
+ glyphsToCharactersBuffer + endGlyphIndexPlusOne );
- // Clear the characters per glyph buffer.
- Length* charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin();
- mVisualModel->mCharactersPerGlyph.Erase( charactersPerGlyphBuffer + mTextUpdateInfo.mStartGlyphIndex,
- charactersPerGlyphBuffer + endGlyphIndexPlusOne );
+ // Clear the characters per glyph buffer.
+ Length* charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin();
+ mVisualModel->mCharactersPerGlyph.Erase( charactersPerGlyphBuffer + mTextUpdateInfo.mStartGlyphIndex,
+ charactersPerGlyphBuffer + endGlyphIndexPlusOne );
- // Clear the positions buffer.
- Vector2* positionsBuffer = mVisualModel->mGlyphPositions.Begin();
- mVisualModel->mGlyphPositions.Erase( positionsBuffer + mTextUpdateInfo.mStartGlyphIndex,
- positionsBuffer + endGlyphIndexPlusOne );
- }
+ // Clear the positions buffer.
+ Vector2* positionsBuffer = mVisualModel->mGlyphPositions.Begin();
+ mVisualModel->mGlyphPositions.Erase( positionsBuffer + mTextUpdateInfo.mStartGlyphIndex,
+ positionsBuffer + endGlyphIndexPlusOne );
+ }
- if( clearLayout )
- {
- // Clear the lines.
- uint32_t startRemoveIndex = mVisualModel->mLines.Count();
- uint32_t endRemoveIndex = startRemoveIndex;
- ClearCharacterRuns( startIndex,
- endIndex,
- mVisualModel->mLines,
- startRemoveIndex,
- endRemoveIndex );
+ if( NO_OPERATION != ( LAYOUT & operations ) )
+ {
+ // Clear the lines.
+ uint32_t startRemoveIndex = mVisualModel->mLines.Count();
+ uint32_t endRemoveIndex = startRemoveIndex;
+ ClearCharacterRuns( startIndex,
+ endIndex,
+ mVisualModel->mLines,
+ startRemoveIndex,
+ endRemoveIndex );
- // Will update the glyph runs.
- uint32_t startRemoveGlyphIndex = mVisualModel->mLines.Count();
- uint32_t endRemoveGlyphIndex = startRemoveIndex;
- ClearGlyphRuns( mTextUpdateInfo.mStartGlyphIndex,
- endGlyphIndex,
- mVisualModel->mLines,
- startRemoveGlyphIndex,
- endRemoveGlyphIndex );
+ // Will update the glyph runs.
+ startRemoveIndex = mVisualModel->mLines.Count();
+ endRemoveIndex = startRemoveIndex;
+ ClearGlyphRuns( mTextUpdateInfo.mStartGlyphIndex,
+ endGlyphIndexPlusOne - 1u,
+ mVisualModel->mLines,
+ startRemoveIndex,
+ endRemoveIndex );
- // Set the line index from where to insert the new laid-out lines.
- mTextUpdateInfo.mStartLineIndex = startRemoveIndex;
+ // Set the line index from where to insert the new laid-out lines.
+ mTextUpdateInfo.mStartLineIndex = startRemoveIndex;
+
+ LineRun* linesBuffer = mVisualModel->mLines.Begin();
+ mVisualModel->mLines.Erase( linesBuffer + startRemoveIndex,
+ linesBuffer + endRemoveIndex );
+ }
- LineRun* linesBuffer = mVisualModel->mLines.Begin();
- mVisualModel->mLines.Erase( linesBuffer + startRemoveIndex,
- linesBuffer + endRemoveIndex );
+ if( NO_OPERATION != ( COLOR & operations ) )
+ {
+ if( 0u != mVisualModel->mColorIndices.Count() )
+ {
+ ColorIndex* colorIndexBuffer = mVisualModel->mColorIndices.Begin();
+ mVisualModel->mColorIndices.Erase( colorIndexBuffer + mTextUpdateInfo.mStartGlyphIndex,
+ colorIndexBuffer + endGlyphIndexPlusOne );
}
}
}
mTextUpdateInfo.mEstimatedNumberOfLines = std::max( mVisualModel->mLines.Count(), mLogicalModel->mParagraphInfo.Count() );
mVisualModel->ClearCaches();
-
- // TODO finish the mark-up.
- mVisualModel->mColorRuns.Clear();
}
-void Controller::Impl::UpdateModel( OperationsMask operationsRequired )
+bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
{
DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::UpdateModel\n" );
if( NO_OPERATION == operations )
{
// Nothing to do if no operations are pending and required.
- return;
+ return false;
}
Vector<Character>& utf32Characters = mLogicalModel->mText;
if( mTextUpdateInfo.mClearAll ||
( 0u != paragraphCharacters ) )
{
- ClearModelData( startIndex, startIndex + ( ( paragraphCharacters > 0u ) ? paragraphCharacters - 1u : 0u ), operationsRequired );
+ ClearModelData( startIndex, startIndex + ( ( paragraphCharacters > 0u ) ? paragraphCharacters - 1u : 0u ), operations );
}
mTextUpdateInfo.mClearAll = false;
+ // Whether the model is updated.
+ bool updated = false;
+
Vector<LineBreakInfo>& lineBreakInfo = mLogicalModel->mLineBreakInfo;
const Length requestedNumberOfCharacters = mTextUpdateInfo.mRequestedNumberOfCharacters;
- if( GET_LINE_BREAKS & operations )
+ if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
{
// Retrieves the line break info. The line break info is used to split the text in 'paragraphs' to
// calculate the bidirectional info for each 'paragraph'.
// Create the paragraph info.
mLogicalModel->CreateParagraphInfo( startIndex,
requestedNumberOfCharacters );
+ updated = true;
}
Vector<WordBreakInfo>& wordBreakInfo = mLogicalModel->mWordBreakInfo;
- if( GET_WORD_BREAKS & operations )
+ if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) )
{
// Retrieves the word break info. The word break info is used to layout the text (where to wrap the text in lines).
wordBreakInfo.Resize( numberOfCharacters, TextAbstraction::WORD_NO_BREAK );
startIndex,
requestedNumberOfCharacters,
wordBreakInfo );
+ updated = true;
}
- const bool getScripts = GET_SCRIPTS & operations;
- const bool validateFonts = VALIDATE_FONTS & operations;
+ const bool getScripts = NO_OPERATION != ( GET_SCRIPTS & operations );
+ const bool validateFonts = NO_OPERATION != ( VALIDATE_FONTS & operations );
Vector<ScriptRun>& scripts = mLogicalModel->mScriptRuns;
Vector<FontRun>& validFonts = mLogicalModel->mFontRuns;
requestedNumberOfCharacters,
validFonts );
}
+ updated = true;
}
Vector<Character> mirroredUtf32Characters;
bool textMirrored = false;
const Length numberOfParagraphs = mLogicalModel->mParagraphInfo.Count();
- if( BIDI_INFO & operations )
+ if( NO_OPERATION != ( BIDI_INFO & operations ) )
{
Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mLogicalModel->mBidirectionalParagraphInfo;
bidirectionalInfo.Reserve( numberOfParagraphs );
// There is no right to left characters. Clear the directions vector.
mLogicalModel->mCharacterDirections.Clear();
}
+ updated = true;
}
Vector<GlyphInfo>& glyphs = mVisualModel->mGlyphs;
newParagraphGlyphs.Reserve( numberOfParagraphs );
const Length currentNumberOfGlyphs = glyphs.Count();
- if( SHAPE_TEXT & operations )
+ if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
{
const Vector<Character>& textToShape = textMirrored ? mirroredUtf32Characters : utf32Characters;
// Shapes the text.
// Create the 'number of glyphs' per character and the glyph to character conversion tables.
mVisualModel->CreateGlyphsPerCharacterTable( startIndex, mTextUpdateInfo.mStartGlyphIndex, requestedNumberOfCharacters );
mVisualModel->CreateCharacterToGlyphTable( startIndex, mTextUpdateInfo.mStartGlyphIndex, requestedNumberOfCharacters );
+ updated = true;
}
const Length numberOfGlyphs = glyphs.Count() - currentNumberOfGlyphs;
- if( GET_GLYPH_METRICS & operations )
+ if( NO_OPERATION != ( GET_GLYPH_METRICS & operations ) )
{
GlyphInfo* glyphsBuffer = glyphs.Begin();
mMetrics->GetGlyphMetrics( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex, numberOfGlyphs );
glyph.width = 0.f;
glyph.advance = 0.f;
}
+ updated = true;
+ }
+
+ if( NO_OPERATION != ( COLOR & operations ) )
+ {
+ // Set the color runs in glyphs.
+ SetColorSegmentationInfo( mLogicalModel->mColorRuns,
+ mVisualModel->mCharactersToGlyph,
+ mVisualModel->mGlyphsPerCharacter,
+ startIndex,
+ mTextUpdateInfo.mStartGlyphIndex,
+ requestedNumberOfCharacters,
+ mVisualModel->mColors,
+ mVisualModel->mColorIndices );
+
+ updated = true;
}
if( ( NULL != mEventData ) &&
// Set the previous number of characters for the next time the text is updated.
mTextUpdateInfo.mPreviousNumberOfCharacters = numberOfCharacters;
-}
-
-bool Controller::Impl::UpdateModelStyle( OperationsMask operationsRequired )
-{
- bool updated = false;
-
- if( COLOR & operationsRequired )
- {
- // Set the color runs in glyphs.
- SetColorSegmentationInfo( mLogicalModel->mColorRuns,
- mVisualModel->mCharactersToGlyph,
- mVisualModel->mGlyphsPerCharacter,
- mVisualModel->mColorRuns );
-
- updated = true;
- }
return updated;
}
{
// Sets the default text's color.
inputStyle.textColor = mTextColor;
+ inputStyle.isDefaultColor = true;
+
+ inputStyle.familyName.clear();
+ inputStyle.weight = TextAbstraction::FontWeight::NORMAL;
+ inputStyle.width = TextAbstraction::FontWidth::NORMAL;
+ inputStyle.slant = TextAbstraction::FontSlant::NORMAL;
+ inputStyle.size = 0.f;
+
+ inputStyle.familyDefined = false;
+ inputStyle.weightDefined = false;
+ inputStyle.widthDefined = false;
+ inputStyle.slantDefined = false;
+ inputStyle.sizeDefined = false;
// Sets the default font's family name, weight, width, slant and size.
if( mFontDefaults )
{
- inputStyle.familyName = mFontDefaults->mFontDescription.family;
- inputStyle.weight = mFontDefaults->mFontDescription.weight;
- inputStyle.width = mFontDefaults->mFontDescription.width;
- inputStyle.slant = mFontDefaults->mFontDescription.slant;
- inputStyle.size = mFontDefaults->mDefaultPointSize;
+ if( mFontDefaults->familyDefined )
+ {
+ inputStyle.familyName = mFontDefaults->mFontDescription.family;
+ inputStyle.familyDefined = true;
+ }
- inputStyle.familyDefined = mFontDefaults->familyDefined;
- inputStyle.weightDefined = mFontDefaults->weightDefined;
- inputStyle.widthDefined = mFontDefaults->widthDefined;
- inputStyle.slantDefined = mFontDefaults->slantDefined;
- inputStyle.sizeDefined = mFontDefaults->sizeDefined;
- }
- else
- {
- inputStyle.familyName.clear();
- inputStyle.weight = TextAbstraction::FontWeight::NORMAL;
- inputStyle.width = TextAbstraction::FontWidth::NORMAL;
- inputStyle.slant = TextAbstraction::FontSlant::NORMAL;
- inputStyle.size = 0.f;
+ if( mFontDefaults->weightDefined )
+ {
+ inputStyle.weight = mFontDefaults->mFontDescription.weight;
+ inputStyle.weightDefined = true;
+ }
+
+ if( mFontDefaults->widthDefined )
+ {
+ inputStyle.width = mFontDefaults->mFontDescription.width;
+ inputStyle.widthDefined = true;
+ }
- inputStyle.familyDefined = false;
- inputStyle.weightDefined = false;
- inputStyle.widthDefined = false;
- inputStyle.slantDefined = false;
- inputStyle.sizeDefined = false;
+ if( mFontDefaults->slantDefined )
+ {
+ inputStyle.slant = mFontDefaults->mFontDescription.slant;
+ inputStyle.slantDefined = true;
+ }
+
+ if( mFontDefaults->sizeDefined )
+ {
+ inputStyle.size = mFontDefaults->mDefaultPointSize;
+ inputStyle.sizeDefined = true;
+ }
}
}
mEventData->mUpdateLeftSelectionPosition = true;
mEventData->mUpdateRightSelectionPosition = true;
+ mEventData->mUpdateCursorPosition = false;
mEventData->mScrollAfterUpdatePosition = ( mEventData->mLeftSelectionPosition != mEventData->mRightSelectionPosition );
}
// Scroll after delete.
mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
- mEventData->mScrollAfterDelete = true;
}
- // Udpade the cursor position and the decorator.
- // Scroll after the position is updated if is not scrolling after delete.
- mEventData->mUpdateCursorPosition = true;
- mEventData->mScrollAfterUpdatePosition = !mEventData->mScrollAfterDelete;
mEventData->mDecoratorUpdated = true;
}
}
void Controller::Impl::HideClipboard()
{
- if( mClipboard )
+ if( mClipboard && mClipboardHideEnabled )
{
mClipboard.HideClipboard();
}
}
+void Controller::Impl::SetClipboardHideEnable(bool enable)
+{
+ mClipboardHideEnabled = enable;
+}
+
bool Controller::Impl::CopyStringToClipboard( std::string& source )
{
//Send string to clipboard
return logicalIndex;
}
- // Find which line is closest
+ // Find which line is closest.
const LineIndex lineIndex = GetClosestLine( visualY );
const LineRun& line = mVisualModel->mLines[lineIndex];
const Vector<Vector2>& positions = mVisualModel->mGlyphPositions;
const Vector2* const positionsBuffer = positions.Begin();
- // Get the visual to logical conversion tables.
- const CharacterIndex* const visualToLogicalBuffer = ( 0u != mLogicalModel->mVisualToLogicalMap.Count() ) ? mLogicalModel->mVisualToLogicalMap.Begin() : NULL;
- const CharacterIndex* const visualToLogicalCursorBuffer = mLogicalModel->mVisualToLogicalCursorMap.Begin();
-
// Get the character to glyph conversion table.
const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin();
// Get the glyphs per character table.
const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin();
- // If the vector is void, there is no right to left characters.
- const bool hasRightToLeftCharacters = NULL != visualToLogicalBuffer;
+ // Get the glyph's info buffer.
+ const GlyphInfo* const glyphInfoBuffer = mVisualModel->mGlyphs.Begin();
const CharacterIndex startCharacter = line.characterRun.characterIndex;
const CharacterIndex endCharacter = line.characterRun.characterIndex + line.characterRun.numberOfCharacters;
DALI_ASSERT_DEBUG( endCharacter <= mLogicalModel->mText.Count() && "Invalid line info" );
+ // Whether this line is a bidirectional line.
+ const bool bidiLineFetched = mLogicalModel->FetchBidirectionalLineInfo( startCharacter );
+
// Whether there is a hit on a glyph.
bool matched = false;
for( ; !matched && ( visualIndex < endCharacter ); ++visualIndex )
{
// The character in logical order.
- const CharacterIndex characterLogicalOrderIndex = hasRightToLeftCharacters ? *( visualToLogicalBuffer + visualIndex ) : visualIndex;
+ const CharacterIndex characterLogicalOrderIndex = ( bidiLineFetched ? mLogicalModel->GetLogicalCharacterIndex( visualIndex ) : visualIndex );
// Get the script of the character.
const Script script = mLogicalModel->GetScript( characterLogicalOrderIndex );
{
// Get the first character/glyph of the group of glyphs.
const CharacterIndex firstVisualCharacterIndex = 1u + visualIndex - numberOfCharacters;
- const CharacterIndex firstLogicalCharacterIndex = hasRightToLeftCharacters ? *( visualToLogicalBuffer + firstVisualCharacterIndex ) : firstVisualCharacterIndex;
+ const CharacterIndex firstLogicalCharacterIndex = ( bidiLineFetched ? mLogicalModel->GetLogicalCharacterIndex( firstVisualCharacterIndex ) : firstVisualCharacterIndex );
const GlyphIndex firstLogicalGlyphIndex = *( charactersToGlyphBuffer + firstLogicalCharacterIndex );
// Get the metrics for the group of glyphs.
GetGlyphsMetrics( firstLogicalGlyphIndex,
numberOfGlyphs,
glyphMetrics,
- mVisualModel,
+ glyphInfoBuffer,
mMetrics );
// Get the position of the first glyph.
}
-
// Return the logical position of the cursor in characters.
if( !matched )
visualIndex = endCharacter;
}
- logicalIndex = hasRightToLeftCharacters ? *( visualToLogicalCursorBuffer + visualIndex ) : visualIndex;
+ logicalIndex = ( bidiLineFetched ? mLogicalModel->GetLogicalCursorIndex( visualIndex ) : visualIndex );
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "%p closest visualIndex %d logicalIndex %d\n", this, visualIndex, logicalIndex );
DALI_ASSERT_DEBUG( ( logicalIndex <= mLogicalModel->mText.Count() && logicalIndex >= 0 ) && "GetClosestCursorIndex - Out of bounds index" );
const Length* const charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin();
const CharacterIndex* const glyphsToCharactersBuffer = mVisualModel->mGlyphsToCharacters.Begin();
const Vector2* const glyphPositionsBuffer = mVisualModel->mGlyphPositions.Begin();
+ const GlyphInfo* const glyphInfoBuffer = mVisualModel->mGlyphs.Begin();
// Convert the cursor position into the glyph position.
const GlyphIndex primaryGlyphIndex = *( charactersToGlyphBuffer + index );
GetGlyphsMetrics( primaryGlyphIndex,
primaryNumberOfGlyphs,
glyphMetrics,
- mVisualModel,
+ glyphInfoBuffer,
mMetrics );
// Whether to add the glyph's advance to the cursor position.
GetGlyphsMetrics( secondaryGlyphIndex,
secondaryNumberOfGlyphs,
glyphMetrics,
- mVisualModel,
+ glyphInfoBuffer,
mMetrics );
// Set the secondary cursor's position.
void Controller::Impl::ScrollToMakePositionVisible( const Vector2& position )
{
+ const float cursorWidth = mEventData->mDecorator ? mEventData->mDecorator->GetCursorWidth() : 0.f;
+
// position is in actor's coords.
- const float positionEnd = position.x + ( mEventData->mDecorator ? mEventData->mDecorator->GetCursorWidth() : 0.f );
+ const float positionEnd = position.x + cursorWidth;
// Transform the position to decorator coords.
const float alignment = IsShowingRealText() ? mAlignmentOffset.x : 0.f;
mEventData->mScrollPosition.x = currentCursorPosition.x - cursorInfo.primaryPosition.x - mAlignmentOffset.x;
ClampHorizontalScroll( mVisualModel->GetLayoutSize() );
+
+ // Makes the new cursor position visible if needed.
+ ScrollToMakePositionVisible( cursorInfo.primaryPosition );
}
void Controller::Impl::RequestRelayout()