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-relayouter.cpp;h=527bb9962ac2b81cad3843c08b6c7e094e0b1b08;hp=8888859fc1df857b1b9a78bcd3f69d088998216f;hb=9012617eed6ae42908bbb15363cc9db49af44e2d;hpb=c4f615acb91de4d6809319fb72700d22298b81c8 diff --git a/dali-toolkit/internal/text/text-controller-relayouter.cpp b/dali-toolkit/internal/text/text-controller-relayouter.cpp index 8888859..527bb99 100644 --- a/dali-toolkit/internal/text/text-controller-relayouter.cpp +++ b/dali-toolkit/internal/text/text-controller-relayouter.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 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. @@ -24,6 +24,7 @@ // INTERNAL INCLUDES #include +#include #include namespace @@ -48,86 +49,152 @@ namespace Toolkit { namespace Text { -Vector3 Controller::Relayouter::GetNaturalSize(Controller& controller) +Size Controller::Relayouter::CalculateLayoutSizeOnRequiredControllerSize(Controller& controller, const Size& requestedControllerSize, const OperationsMask& requestedOperationsMask) { - DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->Controller::GetNaturalSize\n"); - Vector3 naturalSize; - - // Make sure the model is up-to-date before layouting - controller.ProcessModifyEvents(); + DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->CalculateLayoutSizeOnRequiredControllerSize\n"); + Size calculatedLayoutSize; Controller::Impl& impl = *controller.mImpl; ModelPtr& model = impl.mModel; VisualModelPtr& visualModel = model->mVisualModel; - if(impl.mRecalculateNaturalSize) + + // Operations that can be done only once until the text changes. + const OperationsMask onlyOnceOperations = static_cast(CONVERT_TO_UTF32 | + GET_SCRIPTS | + VALIDATE_FONTS | + GET_LINE_BREAKS | + BIDI_INFO | + SHAPE_TEXT | + GET_GLYPH_METRICS); + + const OperationsMask sizeOperations = static_cast(LAYOUT | ALIGN | REORDER); + + // Set the update info to relayout the whole text. + TextUpdateInfo& textUpdateInfo = impl.mTextUpdateInfo; + if((0 == textUpdateInfo.mNumberOfCharactersToAdd) && + (0 == textUpdateInfo.mPreviousNumberOfCharacters) && + ((visualModel->mControlSize.width < Math::MACHINE_EPSILON_1000) || (visualModel->mControlSize.height < Math::MACHINE_EPSILON_1000))) { - // Operations that can be done only once until the text changes. - const OperationsMask onlyOnceOperations = static_cast(CONVERT_TO_UTF32 | - GET_SCRIPTS | - VALIDATE_FONTS | - GET_LINE_BREAKS | - BIDI_INFO | - SHAPE_TEXT | - GET_GLYPH_METRICS); + textUpdateInfo.mNumberOfCharactersToAdd = model->mLogicalModel->mText.Count(); + } + textUpdateInfo.mParagraphCharacterIndex = 0u; + textUpdateInfo.mRequestedNumberOfCharacters = model->mLogicalModel->mText.Count(); - // Set the update info to relayout the whole text. - TextUpdateInfo& textUpdateInfo = impl.mTextUpdateInfo; - textUpdateInfo.mParagraphCharacterIndex = 0u; - textUpdateInfo.mRequestedNumberOfCharacters = model->mLogicalModel->mText.Count(); + // Get a reference to the pending operations member + OperationsMask& operationsPending = impl.mOperationsPending; - // Make sure the model is up-to-date before layouting - impl.UpdateModel(onlyOnceOperations); + // Store the actual control's size to restore later. + const Size actualControlSize = visualModel->mControlSize; + + // Whether the text control is editable + const bool isEditable = NULL != impl.mEventData; - // Get a reference to the pending operations member - OperationsMask& operationsPending = impl.mOperationsPending; + if(!isEditable) + { + impl.UpdateModel(onlyOnceOperations); // Layout the text for the new width. - operationsPending = static_cast(operationsPending | LAYOUT | REORDER); + operationsPending = static_cast(operationsPending | requestedOperationsMask); - // Store the actual control's size to restore later. - const Size actualControlSize = visualModel->mControlSize; + DoRelayout(impl, + requestedControllerSize, + static_cast(onlyOnceOperations | requestedOperationsMask), + calculatedLayoutSize); - DoRelayout(controller, - Size(MAX_FLOAT, MAX_FLOAT), - static_cast(onlyOnceOperations | - LAYOUT | REORDER), - naturalSize.GetVectorXY()); + textUpdateInfo.Clear(); + textUpdateInfo.mClearAll = true; // Do not do again the only once operations. operationsPending = static_cast(operationsPending & ~onlyOnceOperations); + } + else + { + // This is to keep Index to the first character to be updated. + // Then restore it after calling Clear method. + auto updateInfoCharIndexBackup = textUpdateInfo.mCharacterIndex; - // Do the size related operations again. - const OperationsMask sizeOperations = static_cast(LAYOUT | - ALIGN | - REORDER); - operationsPending = static_cast(operationsPending | sizeOperations); + // Layout the text for the new width. + // Apply the pending operations, requested operations and the only once operations. + // Then remove onlyOnceOperations + operationsPending = static_cast(operationsPending | requestedOperationsMask | onlyOnceOperations); - // Stores the natural size to avoid recalculate it again - // unless the text/style changes. - visualModel->SetNaturalSize(naturalSize.GetVectorXY()); + // Make sure the model is up-to-date before layouting + impl.UpdateModel(static_cast(operationsPending & ~UPDATE_LAYOUT_SIZE)); - impl.mRecalculateNaturalSize = false; + DoRelayout(impl, + requestedControllerSize, + static_cast(operationsPending & ~UPDATE_LAYOUT_SIZE), + calculatedLayoutSize); // Clear the update info. This info will be set the next time the text is updated. textUpdateInfo.Clear(); - textUpdateInfo.mClearAll = true; - // Restore the actual control's size. - visualModel->mControlSize = actualControlSize; + //TODO: Refactor "DoRelayout" and extract common code of size calculation without modifying attributes of mVisualModel, + //TODO: then calculate GlyphPositions. Lines, Size, Layout for Natural-Size + //TODO: and utilize the values in OperationsPending and TextUpdateInfo without changing the original one. + //TODO: Also it will improve performance because there is no need todo FullRelyout on the next need for layouting. + + // FullRelayoutNeeded should be true because DoRelayout is MAX_FLOAT, MAX_FLOAT. + // By this no need to take backup and restore it. + textUpdateInfo.mFullRelayoutNeeded = true; - DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize calculated %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z); + // Restore mCharacterIndex. Because "Clear" set it to the maximum integer. + // The "CalculateTextUpdateIndices" does not work proprely because the mCharacterIndex will be greater than mPreviousNumberOfCharacters. + // Which apply an assumption to update only the last paragraph. That could cause many of out of index crashes. + textUpdateInfo.mCharacterIndex = updateInfoCharIndexBackup; + } + + // Do the size related operations again. + operationsPending = static_cast(operationsPending | sizeOperations); + + // Restore the actual control's size. + visualModel->mControlSize = actualControlSize; + + return calculatedLayoutSize; +} + +Vector3 Controller::Relayouter::GetNaturalSize(Controller& controller) +{ + DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->Controller::GetNaturalSize\n"); + Vector3 naturalSizeVec3; + + // Make sure the model is up-to-date before layouting + EventHandler::ProcessModifyEvents(controller); + + Controller::Impl& impl = *controller.mImpl; + ModelPtr& model = impl.mModel; + VisualModelPtr& visualModel = model->mVisualModel; + + if(impl.mRecalculateNaturalSize) + { + Size naturalSize; + + // Layout the text for the new width. + OperationsMask requestedOperationsMask = static_cast(LAYOUT | REORDER); + Size sizeMaxWidthAndMaxHeight = Size(MAX_FLOAT, MAX_FLOAT); + + naturalSize = CalculateLayoutSizeOnRequiredControllerSize(controller, sizeMaxWidthAndMaxHeight, requestedOperationsMask); + + // Stores the natural size to avoid recalculate it again + // unless the text/style changes. + visualModel->SetNaturalSize(naturalSize); + naturalSizeVec3 = naturalSize; + + impl.mRecalculateNaturalSize = false; + + DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize calculated %f,%f,%f\n", naturalSizeVec3.x, naturalSizeVec3.y, naturalSizeVec3.z); } else { - naturalSize = visualModel->GetNaturalSize(); + naturalSizeVec3 = visualModel->GetNaturalSize(); - DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize cached %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z); + DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize cached %f,%f,%f\n", naturalSizeVec3.x, naturalSizeVec3.y, naturalSizeVec3.z); } - naturalSize.x = ConvertToEven(naturalSize.x); - naturalSize.y = ConvertToEven(naturalSize.y); + naturalSizeVec3.x = ConvertToEven(naturalSizeVec3.x); + naturalSizeVec3.y = ConvertToEven(naturalSizeVec3.y); - return naturalSize; + return naturalSizeVec3; } bool Controller::Relayouter::CheckForTextFit(Controller& controller, float pointSize, const Size& layoutSize) @@ -137,7 +204,7 @@ bool Controller::Relayouter::CheckForTextFit(Controller& controller, float point TextUpdateInfo& textUpdateInfo = impl.mTextUpdateInfo; impl.mFontDefaults->mFitPointSize = pointSize; impl.mFontDefaults->sizeDefined = true; - controller.ClearFontData(); + impl.ClearFontData(); // Operations that can be done only once until the text changes. const OperationsMask onlyOnceOperations = static_cast(CONVERT_TO_UTF32 | @@ -154,7 +221,7 @@ bool Controller::Relayouter::CheckForTextFit(Controller& controller, float point // Make sure the model is up-to-date before layouting impl.UpdateModel(onlyOnceOperations); - DoRelayout(controller, + DoRelayout(impl, Size(layoutSize.width, MAX_FLOAT), static_cast(onlyOnceOperations | LAYOUT), textSize); @@ -179,10 +246,11 @@ void Controller::Relayouter::FitPointSizeforLayout(Controller& controller, const { ModelPtr& model = impl.mModel; - bool actualellipsis = model->mElideEnabled; - float minPointSize = impl.mTextFitMinSize; - float maxPointSize = impl.mTextFitMaxSize; - float pointInterval = impl.mTextFitStepSize; + bool actualellipsis = model->mElideEnabled; + float minPointSize = impl.mTextFitMinSize; + float maxPointSize = impl.mTextFitMaxSize; + float pointInterval = impl.mTextFitStepSize; + float currentFitPointSize = impl.mFontDefaults->mFitPointSize; model->mElideEnabled = false; Vector pointSizeArray; @@ -221,18 +289,23 @@ void Controller::Relayouter::FitPointSizeforLayout(Controller& controller, const } } - model->mElideEnabled = actualellipsis; + model->mElideEnabled = actualellipsis; + if(currentFitPointSize != pointSizeArray[bestSizeIndex]) + { + impl.mTextFitChanged = true; + } impl.mFontDefaults->mFitPointSize = pointSizeArray[bestSizeIndex]; impl.mFontDefaults->sizeDefined = true; - controller.ClearFontData(); + impl.ClearFontData(); } } float Controller::Relayouter::GetHeightForWidth(Controller& controller, float width) { DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->Controller::GetHeightForWidth %p width %f\n", &controller, width); + // Make sure the model is up-to-date before layouting - controller.ProcessModifyEvents(); + EventHandler::ProcessModifyEvents(controller); Controller::Impl& impl = *controller.mImpl; ModelPtr& model = impl.mModel; @@ -240,57 +313,16 @@ float Controller::Relayouter::GetHeightForWidth(Controller& controller, float wi TextUpdateInfo& textUpdateInfo = impl.mTextUpdateInfo; Size layoutSize; + if(fabsf(width - visualModel->mControlSize.width) > Math::MACHINE_EPSILON_1000 || textUpdateInfo.mFullRelayoutNeeded || textUpdateInfo.mClearAll) { - // Operations that can be done only once until the text changes. - const OperationsMask onlyOnceOperations = static_cast(CONVERT_TO_UTF32 | - GET_SCRIPTS | - VALIDATE_FONTS | - GET_LINE_BREAKS | - BIDI_INFO | - SHAPE_TEXT | - GET_GLYPH_METRICS); - - // Set the update info to relayout the whole text. - textUpdateInfo.mParagraphCharacterIndex = 0u; - textUpdateInfo.mRequestedNumberOfCharacters = model->mLogicalModel->mText.Count(); - - // Make sure the model is up-to-date before layouting - impl.UpdateModel(onlyOnceOperations); - - // Get a reference to the pending operations member - OperationsMask& operationsPending = impl.mOperationsPending; - // Layout the text for the new width. - operationsPending = static_cast(operationsPending | LAYOUT); - - // Store the actual control's width. - const float actualControlWidth = visualModel->mControlSize.width; - - DoRelayout(controller, - Size(width, MAX_FLOAT), - static_cast(onlyOnceOperations | - LAYOUT), - layoutSize); - - // Do not do again the only once operations. - operationsPending = static_cast(operationsPending & ~onlyOnceOperations); - - // Do the size related operations again. - const OperationsMask sizeOperations = static_cast(LAYOUT | - ALIGN | - REORDER); + OperationsMask requestedOperationsMask = static_cast(LAYOUT); + Size sizeRequestedWidthAndMaxHeight = Size(width, MAX_FLOAT); - operationsPending = static_cast(operationsPending | sizeOperations); - - // Clear the update info. This info will be set the next time the text is updated. - textUpdateInfo.Clear(); - textUpdateInfo.mClearAll = true; - - // Restore the actual control's width. - visualModel->mControlSize.width = actualControlWidth; + layoutSize = CalculateLayoutSizeOnRequiredControllerSize(controller, sizeRequestedWidthAndMaxHeight, requestedOperationsMask); DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth calculated %f\n", layoutSize.height); } @@ -383,8 +415,11 @@ Controller::UpdateTextType Controller::Relayouter::Relayout(Controller& controll textUpdateInfo.mCharacterIndex = 0u; } - if(model->mMatchSystemLanguageDirection && impl.mLayoutDirection != layoutDirection) + bool layoutDirectionChanged = false; + if(impl.mLayoutDirection != layoutDirection) { + // Flag to indicate that the layout direction has changed. + layoutDirectionChanged = true; // Clear the update info. This info will be set the next time the text is updated. textUpdateInfo.mClearAll = true; // Apply modifications to the model @@ -393,6 +428,7 @@ Controller::UpdateTextType Controller::Relayouter::Relayout(Controller& controll GET_GLYPH_METRICS | SHAPE_TEXT | UPDATE_DIRECTION | + ALIGN | LAYOUT | BIDI_INFO | REORDER); @@ -400,12 +436,12 @@ Controller::UpdateTextType Controller::Relayouter::Relayout(Controller& controll } // Make sure the model is up-to-date before layouting. - controller.ProcessModifyEvents(); + EventHandler::ProcessModifyEvents(controller); bool updated = impl.UpdateModel(operationsPending); // Layout the text. Size layoutSize; - updated = DoRelayout(controller, size, operationsPending, layoutSize) || updated; + updated = DoRelayout(impl, size, operationsPending, layoutSize) || updated; if(updated) { @@ -429,18 +465,42 @@ Controller::UpdateTextType Controller::Relayouter::Relayout(Controller& controll if(!isEditable || !controller.IsMultiLineEnabled()) { // After doing the text layout, the vertical offset to place the actor in the desired position can be calculated. - controller.CalculateVerticalOffset(size); + CalculateVerticalOffset(impl, size); + } + else // TextEditor + { + // If layoutSize is bigger than size, vertical align has no meaning. + if(layoutSize.y < size.y) + { + CalculateVerticalOffset(impl, size); + if(impl.mEventData) + { + impl.mEventData->mScrollAfterDelete = false; + } + } } if(isEditable) { - if(newSize) + if(newSize || layoutDirectionChanged) { - // If there is a new size, the scroll position needs to be clamped. + // If there is a new size or layout direction is changed, the scroll position needs to be clamped. impl.ClampHorizontalScroll(layoutSize); // Update the decorator's positions is needed if there is a new size. impl.mEventData->mDecorator->UpdatePositions(model->mScrollPosition - offset); + + // All decorator elements need to be updated. + if(EventData::IsEditingState(impl.mEventData->mState)) + { + impl.mEventData->mScrollAfterUpdatePosition = true; + impl.mEventData->mUpdateCursorPosition = true; + impl.mEventData->mUpdateGrabHandlePosition = true; + } + else if(impl.mEventData->mState == EventData::SELECTING) + { + impl.mEventData->mUpdateHighlightBox = true; + } } // Move the cursor, grab handle etc. @@ -457,13 +517,11 @@ Controller::UpdateTextType Controller::Relayouter::Relayout(Controller& controll return updateTextType; } -bool Controller::Relayouter::DoRelayout(Controller& controller, const Size& size, OperationsMask operationsRequired, Size& layoutSize) +bool Controller::Relayouter::DoRelayout(Controller::Impl& impl, const Size& size, OperationsMask operationsRequired, Size& layoutSize) { - DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->Controller::DoRelayout %p size %f,%f\n", &controller, size.width, size.height); + DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->Controller::Relayouter::DoRelayout %p size %f,%f\n", &impl, size.width, size.height); bool viewUpdated(false); - Controller::Impl& impl = *controller.mImpl; - // Calculate the operations to be done. const OperationsMask operations = static_cast(impl.mOperationsPending & operationsRequired); @@ -498,7 +556,7 @@ bool Controller::Relayouter::DoRelayout(Controller& controller, const Size& size (lastIndex > charactersToGlyph.Count() && charactersToGlyph.Count() > 0u)) { std::string currentText; - controller.GetText(currentText); + impl.GetText(currentText); DALI_LOG_ERROR("Controller::DoRelayout: Attempting to access invalid buffer\n"); DALI_LOG_ERROR("Current text is: %s\n", currentText.c_str()); @@ -542,6 +600,7 @@ bool Controller::Relayouter::DoRelayout(Controller& controller, const Size& size // Update the ellipsis bool elideTextEnabled = impl.mModel->mElideEnabled; + auto ellipsisPosition = impl.mModel->mEllipsisPosition; if(NULL != impl.mEventData) { @@ -558,17 +617,21 @@ bool Controller::Relayouter::DoRelayout(Controller& controller, const Size& size // Reset the scroll position in inactive state if(elideTextEnabled && (impl.mEventData->mState == EventData::INACTIVE)) { - controller.ResetScrollPosition(); + impl.ResetScrollPosition(); } } // Update the visual model. - bool isAutoScrollEnabled = impl.mIsAutoScrollEnabled; + bool isAutoScrollEnabled = impl.mIsAutoScrollEnabled; + bool isAutoScrollMaxTextureExceeded = impl.mIsAutoScrollMaxTextureExceeded; + Size newLayoutSize; viewUpdated = impl.mLayoutEngine.LayoutText(layoutParameters, newLayoutSize, elideTextEnabled, - isAutoScrollEnabled); + isAutoScrollEnabled, + isAutoScrollMaxTextureExceeded, + ellipsisPosition); impl.mIsAutoScrollEnabled = isAutoScrollEnabled; viewUpdated = viewUpdated || (newLayoutSize != layoutSize); @@ -597,21 +660,51 @@ bool Controller::Relayouter::DoRelayout(Controller& controller, const Size& size if(NO_OPERATION != (ALIGN & operations)) { - // The laid-out lines. - Vector& lines = visualModel->mLines; + DoRelayoutHorizontalAlignment(impl, size, startIndex, requestedNumberOfCharacters); + viewUpdated = true; + } +#if defined(DEBUG_ENABLED) + std::string currentText; + impl.GetText(currentText); + DALI_LOG_INFO(gLogFilter, Debug::Concise, "Controller::Relayouter::DoRelayout [%p] mImpl->mIsTextDirectionRTL[%s] [%s]\n", &impl, (impl.mIsTextDirectionRTL) ? "true" : "false", currentText.c_str()); +#endif + DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::Relayouter::DoRelayout, view updated %s\n", (viewUpdated ? "true" : "false")); + return viewUpdated; +} - CharacterIndex alignStartIndex = startIndex; - Length alignRequestedNumberOfCharacters = requestedNumberOfCharacters; +void Controller::Relayouter::DoRelayoutHorizontalAlignment(Controller::Impl& impl, + const Size& size, + const CharacterIndex startIndex, + const Length requestedNumberOfCharacters) +{ + // The visualModel + VisualModelPtr& visualModel = impl.mModel->mVisualModel; - // the whole text needs to be full aligned. - // If you do not do a full aligned, only the last line of the multiline input is aligned. - if(impl.mEventData && impl.mEventData->mUpdateAlignment) - { - alignStartIndex = 0u; - alignRequestedNumberOfCharacters = impl.mModel->mLogicalModel->mText.Count(); - impl.mEventData->mUpdateAlignment = false; - } + // The laid-out lines. + Vector& lines = visualModel->mLines; + + CharacterIndex alignStartIndex = startIndex; + Length alignRequestedNumberOfCharacters = requestedNumberOfCharacters; + // the whole text needs to be full aligned. + // If you do not do a full aligned, only the last line of the multiline input is aligned. + if(impl.mEventData && impl.mEventData->mUpdateAlignment) + { + alignStartIndex = 0u; + alignRequestedNumberOfCharacters = impl.mModel->mLogicalModel->mText.Count(); + impl.mEventData->mUpdateAlignment = false; + } + + // If there is no BoundedParagraphRuns then apply the alignment of controller. + // Check whether the layout is single line. It's needed to apply one alignment for single-line. + // In single-line layout case we need to check whether to follow the alignment of controller or the first BoundedParagraph. + // Apply BoundedParagraph's alignment if and only if there is one BoundedParagraph contains all characters. Otherwise follow controller's alignment. + const bool isFollowControllerAlignment = ((impl.mModel->GetNumberOfBoundedParagraphRuns() == 0u) || + ((Layout::Engine::SINGLE_LINE_BOX == impl.mLayoutEngine.GetLayout()) && + (impl.mModel->GetBoundedParagraphRuns()[0].characterRun.numberOfCharacters != impl.mModel->mLogicalModel->mText.Count()))); + + if(isFollowControllerAlignment) + { // Need to align with the control's size as the text may contain lines // starting either with left to right text or right to left. impl.mLayoutEngine.Align(size, @@ -621,29 +714,103 @@ bool Controller::Relayouter::DoRelayout(Controller& controller, const Size& size lines, impl.mModel->mAlignmentOffset, impl.mLayoutDirection, - impl.mModel->mMatchSystemLanguageDirection); + (impl.mModel->mMatchLayoutDirection != DevelText::MatchLayoutDirection::CONTENTS)); + } + else + { + //Override the controller horizontal-alignment by horizontal-alignment of bounded paragraph. + const Length& numberOfBoundedParagraphRuns = impl.mModel->GetNumberOfBoundedParagraphRuns(); + const Vector& boundedParagraphRuns = impl.mModel->GetBoundedParagraphRuns(); + const CharacterIndex alignEndIndex = alignStartIndex + alignRequestedNumberOfCharacters - 1u; - viewUpdated = true; + Length alignIndex = alignStartIndex; + Length boundedParagraphRunIndex = 0u; + + while(alignIndex <= alignEndIndex && boundedParagraphRunIndex < numberOfBoundedParagraphRuns) + { + //BP: BoundedParagraph + const BoundedParagraphRun& boundedParagraphRun = boundedParagraphRuns[boundedParagraphRunIndex]; + const CharacterIndex& characterStartIndexBP = boundedParagraphRun.characterRun.characterIndex; + const Length& numberOfCharactersBP = boundedParagraphRun.characterRun.numberOfCharacters; + const CharacterIndex characterEndIndexBP = characterStartIndexBP + numberOfCharactersBP - 1u; + + CharacterIndex decidedAlignStartIndex = alignIndex; + Length decidedAlignNumberOfCharacters = alignEndIndex - alignIndex + 1u; + Text::HorizontalAlignment::Type decidedHorizontalAlignment = impl.mModel->mHorizontalAlignment; + + /* + * Shortcuts to explain indexes cases: + * + * AS: Alignment Start Index + * AE: Alignment End Index + * PS: Paragraph Start Index + * PE: Paragraph End Index + * B: BoundedParagraph Alignment + * M: Model Alignment + * + */ + + if(alignIndex < characterStartIndexBP && characterStartIndexBP <= alignEndIndex) /// AS.MMMMMM.PS--------AE + { + // Alignment from "Alignment Start Index" to index before "Paragraph Start Index" according to "Model Alignment" + decidedAlignStartIndex = alignIndex; + decidedAlignNumberOfCharacters = characterStartIndexBP - alignIndex; + decidedHorizontalAlignment = impl.mModel->mHorizontalAlignment; + + // Need to re-heck the case of current bounded paragraph + alignIndex = characterStartIndexBP; // Shift AS to be PS + } + else if((characterStartIndexBP <= alignIndex && alignIndex <= characterEndIndexBP) || /// ---PS.BBBBBBB.AS.BBBBBBB.PE--- + (characterStartIndexBP <= alignEndIndex && alignEndIndex <= characterEndIndexBP)) /// ---PS.BBBBBB.AE.BBBBBBB.PE--- + { + // Alignment from "Paragraph Start Index" to "Paragraph End Index" according to "BoundedParagraph Alignment" + decidedAlignStartIndex = characterStartIndexBP; + decidedAlignNumberOfCharacters = numberOfCharactersBP; + decidedHorizontalAlignment = boundedParagraphRun.horizontalAlignmentDefined ? boundedParagraphRun.horizontalAlignment : impl.mModel->mHorizontalAlignment; + + alignIndex = characterEndIndexBP + 1u; // Shift AS to be after PE direct + boundedParagraphRunIndex++; // Align then check the case of next bounded paragraph + } + else + { + boundedParagraphRunIndex++; // Check the case of next bounded paragraph + continue; + } + + impl.mLayoutEngine.Align(size, + decidedAlignStartIndex, + decidedAlignNumberOfCharacters, + decidedHorizontalAlignment, + lines, + impl.mModel->mAlignmentOffset, + impl.mLayoutDirection, + (impl.mModel->mMatchLayoutDirection != DevelText::MatchLayoutDirection::CONTENTS)); + } + + //Align the remaining that is not aligned + if(alignIndex <= alignEndIndex) + { + impl.mLayoutEngine.Align(size, + alignIndex, + (alignEndIndex - alignIndex + 1u), + impl.mModel->mHorizontalAlignment, + lines, + impl.mModel->mAlignmentOffset, + impl.mLayoutDirection, + (impl.mModel->mMatchLayoutDirection != DevelText::MatchLayoutDirection::CONTENTS)); + } } -#if defined(DEBUG_ENABLED) - std::string currentText; - controller.GetText(currentText); - DALI_LOG_INFO(gLogFilter, Debug::Concise, "Controller::DoRelayout [%p] mImpl->mIsTextDirectionRTL[%s] [%s]\n", &controller, (impl.mIsTextDirectionRTL) ? "true" : "false", currentText.c_str()); -#endif - DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::DoRelayout, view updated %s\n", (viewUpdated ? "true" : "false")); - return viewUpdated; } -void Controller::Relayouter::CalculateVerticalOffset(Controller& controller, const Size& controlSize) +void Controller::Relayouter::CalculateVerticalOffset(Controller::Impl& impl, const Size& controlSize) { - Controller::Impl& impl = *controller.mImpl; - ModelPtr& model = impl.mModel; - VisualModelPtr& visualModel = model->mVisualModel; - Size layoutSize = model->mVisualModel->GetLayoutSize(); - Size oldLayoutSize = layoutSize; - float offsetY = 0.f; - bool needRecalc = false; - float defaultFontLineHeight = impl.GetDefaultFontLineHeight(); + ModelPtr& model = impl.mModel; + VisualModelPtr& visualModel = model->mVisualModel; + Size layoutSize = model->mVisualModel->GetLayoutSize(); + Size oldLayoutSize = layoutSize; + float offsetY = 0.f; + bool needRecalc = false; + float defaultFontLineHeight = impl.GetDefaultFontLineHeight(); if(fabsf(layoutSize.height) < Math::MACHINE_EPSILON_1000) { @@ -651,12 +818,14 @@ void Controller::Relayouter::CalculateVerticalOffset(Controller& controller, con layoutSize.height = defaultFontLineHeight; } - if (layoutSize.height != defaultFontLineHeight) + // Whether the text control is editable + const bool isEditable = NULL != impl.mEventData; + if(isEditable && layoutSize.height != defaultFontLineHeight && impl.IsShowingPlaceholderText()) { // This code prevents the wrong positioning of cursor when the layout size is bigger/smaller than defaultFontLineHeight. // This situation occurs when the size of placeholder text is different from the default text. layoutSize.height = defaultFontLineHeight; - needRecalc = true; + needRecalc = true; } switch(model->mVerticalAlignment) @@ -664,34 +833,33 @@ void Controller::Relayouter::CalculateVerticalOffset(Controller& controller, con case VerticalAlignment::TOP: { model->mScrollPosition.y = 0.f; - offsetY = 0.f; + offsetY = 0.f; break; } case VerticalAlignment::CENTER: { model->mScrollPosition.y = floorf(0.5f * (controlSize.height - layoutSize.height)); // try to avoid pixel alignment. - if (needRecalc) offsetY = floorf(0.5f * (layoutSize.height - oldLayoutSize.height)); + if(needRecalc) offsetY = floorf(0.5f * (layoutSize.height - oldLayoutSize.height)); break; } case VerticalAlignment::BOTTOM: { model->mScrollPosition.y = controlSize.height - layoutSize.height; - if (needRecalc) offsetY = layoutSize.height - oldLayoutSize.height; + if(needRecalc) offsetY = layoutSize.height - oldLayoutSize.height; break; } } - if (needRecalc) + if(needRecalc) { // Update glyphPositions according to recalculation. - const Length positionCount = visualModel->mGlyphPositions.Count(); + const Length positionCount = visualModel->mGlyphPositions.Count(); Vector& glyphPositions = visualModel->mGlyphPositions; for(Length index = 0u; index < positionCount; index++) { glyphPositions[index].y += offsetY; } } - } } // namespace Text