/*
- * Copyright (c) 2015 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.
#include <dali-toolkit/internal/text/text-controller-impl.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/adaptor-framework/key.h>
+#include <dali/devel-api/adaptor-framework/window-devel.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/rendering/renderer.h>
+#include <cmath>
// INTERNAL INCLUDES
-#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/cursor-helper-functions.h>
-#include <dali-toolkit/internal/text/multi-language-support.h>
-#include <dali-toolkit/internal/text/segmentation.h>
-#include <dali-toolkit/internal/text/shaper.h>
+#include <dali-toolkit/internal/text/glyph-metrics-helper.h>
+#include <dali-toolkit/internal/text/text-control-interface.h>
+#include <dali-toolkit/internal/text/text-controller-impl-data-clearer.h>
+#include <dali-toolkit/internal/text/text-controller-impl-event-handler.h>
+#include <dali-toolkit/internal/text/text-controller-impl-model-updater.h>
+#include <dali-toolkit/internal/text/text-controller-placeholder-handler.h>
+#include <dali-toolkit/internal/text/text-controller-relayouter.h>
+#include <dali-toolkit/internal/text/text-editable-control-interface.h>
+#include <dali-toolkit/internal/text/text-enumerations-impl.h>
#include <dali-toolkit/internal/text/text-run-container.h>
+#include <dali-toolkit/internal/text/text-selection-handle-controller.h>
+#include <dali-toolkit/internal/text/underlined-glyph-run.h>
+
+using namespace Dali;
namespace
{
-
#if defined(DEBUG_ENABLED)
- Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
+Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
#endif
+constexpr float MAX_FLOAT = std::numeric_limits<float>::max();
+
+const std::string EMPTY_STRING("");
+
} // namespace
-namespace Dali
+namespace Dali::Toolkit::Text
{
-
-namespace Toolkit
+namespace
{
-
-namespace Text
+void SetDefaultInputStyle(InputStyle& inputStyle, const FontDefaults* const fontDefaults, const Vector4& textColor)
{
+ // Sets the default text's color.
+ inputStyle.textColor = textColor;
+ inputStyle.isDefaultColor = true;
-EventData::EventData( DecoratorPtr decorator )
-: mDecorator( decorator ),
- mImfManager(),
- mPlaceholderTextActive(),
- mPlaceholderTextInactive(),
- mPlaceholderTextColor( 0.8f, 0.8f, 0.8f, 0.8f ),
- mEventQueue(),
- mScrollPosition(),
- mState( INACTIVE ),
- mPrimaryCursorPosition( 0u ),
- mLeftSelectionPosition( 0u ),
- mRightSelectionPosition( 0u ),
- mPreEditStartPosition( 0u ),
- mPreEditLength( 0u ),
- mIsShowingPlaceholderText( false ),
- mPreEditFlag( false ),
- mDecoratorUpdated( false ),
- mCursorBlinkEnabled( true ),
- mGrabHandleEnabled( true ),
- mGrabHandlePopupEnabled( true ),
- mSelectionEnabled( true ),
- mHorizontalScrollingEnabled( true ),
- mVerticalScrollingEnabled( false ),
- mUpdateCursorPosition( false ),
- mUpdateLeftSelectionPosition( false ),
- mUpdateRightSelectionPosition( false ),
- mScrollAfterUpdatePosition( false ),
- mScrollAfterDelete( false ),
- mAllTextSelected( false ),
- mUpdateInputStyle( false )
-{
- mImfManager = ImfManager::Get();
-}
-
-EventData::~EventData()
-{}
+ inputStyle.familyName.clear();
+ inputStyle.weight = TextAbstraction::FontWeight::NORMAL;
+ inputStyle.width = TextAbstraction::FontWidth::NORMAL;
+ inputStyle.slant = TextAbstraction::FontSlant::NORMAL;
+ inputStyle.size = 0.f;
-bool Controller::Impl::ProcessInputEvents()
+ inputStyle.lineSpacing = 0.f;
+
+ inputStyle.underlineProperties.clear();
+ inputStyle.shadowProperties.clear();
+ inputStyle.embossProperties.clear();
+ inputStyle.outlineProperties.clear();
+
+ inputStyle.isFamilyDefined = false;
+ inputStyle.isWeightDefined = false;
+ inputStyle.isWidthDefined = false;
+ inputStyle.isSlantDefined = false;
+ inputStyle.isSizeDefined = false;
+
+ inputStyle.isLineSpacingDefined = false;
+
+ inputStyle.isUnderlineDefined = false;
+ inputStyle.isShadowDefined = false;
+ inputStyle.isEmbossDefined = false;
+ inputStyle.isOutlineDefined = false;
+
+ // Sets the default font's family name, weight, width, slant and size.
+ if(fontDefaults)
+ {
+ if(fontDefaults->familyDefined)
+ {
+ inputStyle.familyName = fontDefaults->mFontDescription.family;
+ inputStyle.isFamilyDefined = true;
+ }
+
+ if(fontDefaults->weightDefined)
+ {
+ inputStyle.weight = fontDefaults->mFontDescription.weight;
+ inputStyle.isWeightDefined = true;
+ }
+
+ if(fontDefaults->widthDefined)
+ {
+ inputStyle.width = fontDefaults->mFontDescription.width;
+ inputStyle.isWidthDefined = true;
+ }
+
+ if(fontDefaults->slantDefined)
+ {
+ inputStyle.slant = fontDefaults->mFontDescription.slant;
+ inputStyle.isSlantDefined = true;
+ }
+
+ if(fontDefaults->sizeDefined)
+ {
+ inputStyle.size = fontDefaults->mDefaultPointSize;
+ inputStyle.isSizeDefined = true;
+ }
+ }
+}
+
+void ChangeTextControllerState(Controller::Impl& impl, EventData::State newState)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::ProcessInputEvents\n" );
- if( NULL == mEventData )
+ EventData* eventData = impl.mEventData;
+
+ if(nullptr == eventData)
{
// Nothing to do if there is no text input.
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::ProcessInputEvents no event data\n" );
- return false;
+ return;
+ }
+
+ DecoratorPtr& decorator = eventData->mDecorator;
+ if(!decorator)
+ {
+ // Nothing to do if there is no decorator.
+ return;
}
- if( mEventData->mDecorator )
+ DALI_LOG_INFO(gLogFilter, Debug::General, "ChangeState state:%d newstate:%d\n", eventData->mState, newState);
+
+ if(eventData->mState != newState)
{
- for( std::vector<Event>::iterator iter = mEventData->mEventQueue.begin();
- iter != mEventData->mEventQueue.end();
- ++iter )
+ eventData->mPreviousState = eventData->mState;
+ eventData->mState = newState;
+
+ switch(eventData->mState)
{
- switch( iter->type )
+ case EventData::INACTIVE:
+ {
+ decorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
+ decorator->StopCursorBlink();
+ decorator->SetHandleActive(GRAB_HANDLE, false);
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
+ decorator->SetHighlightActive(false);
+ decorator->SetPopupActive(false);
+ eventData->mDecoratorUpdated = true;
+ break;
+ }
+
+ case EventData::INTERRUPTED:
+ {
+ decorator->SetHandleActive(GRAB_HANDLE, false);
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
+ decorator->SetHighlightActive(false);
+ decorator->SetPopupActive(false);
+ eventData->mDecoratorUpdated = true;
+ break;
+ }
+
+ case EventData::SELECTING:
+ {
+ decorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
+ decorator->StopCursorBlink();
+ decorator->SetHandleActive(GRAB_HANDLE, false);
+ if(eventData->mGrabHandleEnabled)
+ {
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, true);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, true);
+ }
+ decorator->SetHighlightActive(true);
+ if(eventData->mGrabHandlePopupEnabled)
+ {
+ impl.SetPopupButtons();
+ decorator->SetPopupActive(true);
+ }
+ eventData->mDecoratorUpdated = true;
+ break;
+ }
+
+ case EventData::EDITING:
{
- case Event::CURSOR_KEY_EVENT:
+ decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
+ if(eventData->mCursorBlinkEnabled)
{
- OnCursorKeyEvent( *iter );
- break;
+ decorator->StartCursorBlink();
}
- case Event::TAP_EVENT:
+ // Grab handle is not shown until a tap is received whilst EDITING
+ decorator->SetHandleActive(GRAB_HANDLE, false);
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
+ decorator->SetHighlightActive(false);
+ if(eventData->mGrabHandlePopupEnabled)
{
- OnTapEvent( *iter );
- break;
+ decorator->SetPopupActive(false);
}
- case Event::LONG_PRESS_EVENT:
+ eventData->mDecoratorUpdated = true;
+ break;
+ }
+ case EventData::EDITING_WITH_POPUP:
+ {
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "EDITING_WITH_POPUP \n", newState);
+
+ decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
+ if(eventData->mCursorBlinkEnabled)
+ {
+ decorator->StartCursorBlink();
+ }
+ if(eventData->mSelectionEnabled)
+ {
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
+ decorator->SetHighlightActive(false);
+ }
+ else if(eventData->mGrabHandleEnabled)
+ {
+ decorator->SetHandleActive(GRAB_HANDLE, true);
+ }
+ if(eventData->mGrabHandlePopupEnabled)
+ {
+ impl.SetPopupButtons();
+ decorator->SetPopupActive(true);
+ }
+ eventData->mDecoratorUpdated = true;
+ break;
+ }
+ case EventData::EDITING_WITH_GRAB_HANDLE:
+ {
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "EDITING_WITH_GRAB_HANDLE \n", newState);
+
+ decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
+ if(eventData->mCursorBlinkEnabled)
+ {
+ decorator->StartCursorBlink();
+ }
+ // Grab handle is not shown until a tap is received whilst EDITING
+ if(eventData->mGrabHandleEnabled)
+ {
+ decorator->SetHandleActive(GRAB_HANDLE, true);
+ }
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
+ decorator->SetHighlightActive(false);
+ if(eventData->mGrabHandlePopupEnabled)
+ {
+ decorator->SetPopupActive(false);
+ }
+ eventData->mDecoratorUpdated = true;
+ break;
+ }
+
+ case EventData::SELECTION_HANDLE_PANNING:
+ {
+ decorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
+ decorator->StopCursorBlink();
+ decorator->SetHandleActive(GRAB_HANDLE, false);
+ if(eventData->mGrabHandleEnabled)
+ {
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, true);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, true);
+ }
+ decorator->SetHighlightActive(true);
+ if(eventData->mGrabHandlePopupEnabled)
+ {
+ decorator->SetPopupActive(false);
+ }
+ eventData->mDecoratorUpdated = true;
+ break;
+ }
+
+ case EventData::GRAB_HANDLE_PANNING:
+ {
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "GRAB_HANDLE_PANNING \n", newState);
+
+ decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
+ if(eventData->mCursorBlinkEnabled)
+ {
+ decorator->StartCursorBlink();
+ }
+ if(eventData->mGrabHandleEnabled)
+ {
+ decorator->SetHandleActive(GRAB_HANDLE, true);
+ }
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
+ decorator->SetHighlightActive(false);
+ if(eventData->mGrabHandlePopupEnabled)
+ {
+ decorator->SetPopupActive(false);
+ }
+ eventData->mDecoratorUpdated = true;
+ break;
+ }
+
+ case EventData::EDITING_WITH_PASTE_POPUP:
+ {
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "EDITING_WITH_PASTE_POPUP \n", newState);
+
+ decorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
+ if(eventData->mCursorBlinkEnabled)
{
- OnLongPressEvent( *iter );
- break;
+ decorator->StartCursorBlink();
}
- case Event::PAN_EVENT:
+
+ if(eventData->mGrabHandleEnabled)
{
- OnPanEvent( *iter );
- break;
+ decorator->SetHandleActive(GRAB_HANDLE, true);
}
- case Event::GRAB_HANDLE_EVENT:
- case Event::LEFT_SELECTION_HANDLE_EVENT:
- case Event::RIGHT_SELECTION_HANDLE_EVENT: // Fall through
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
+ decorator->SetHighlightActive(false);
+
+ if(eventData->mGrabHandlePopupEnabled)
{
- OnHandleEvent( *iter );
- break;
+ impl.SetPopupButtons();
+ decorator->SetPopupActive(true);
}
- case Event::SELECT:
+ eventData->mDecoratorUpdated = true;
+ break;
+ }
+
+ case EventData::TEXT_PANNING:
+ {
+ decorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
+ decorator->StopCursorBlink();
+ decorator->SetHandleActive(GRAB_HANDLE, false);
+ if(eventData->mDecorator->IsHandleActive(LEFT_SELECTION_HANDLE) ||
+ decorator->IsHandleActive(RIGHT_SELECTION_HANDLE))
{
- OnSelectEvent( *iter );
- break;
+ decorator->SetHandleActive(LEFT_SELECTION_HANDLE, false);
+ decorator->SetHandleActive(RIGHT_SELECTION_HANDLE, false);
+ decorator->SetHighlightActive(true);
}
- case Event::SELECT_ALL:
+
+ if(eventData->mGrabHandlePopupEnabled)
{
- OnSelectAllEvent();
- break;
+ decorator->SetPopupActive(false);
}
+
+ eventData->mDecoratorUpdated = true;
+ break;
}
}
}
+}
- // The cursor must also be repositioned after inserts into the model
- if( mEventData->mUpdateCursorPosition )
+void UpdateCursorPositionForAlignment(Controller::Impl& impl, bool needFullAlignment)
+{
+ EventData* eventData = impl.mEventData;
+
+ // Set the flag to redo the alignment operation
+ impl.mOperationsPending = static_cast<Controller::OperationsMask>(impl.mOperationsPending | Controller::OperationsMask::ALIGN);
+
+ if(eventData)
{
- // Updates the cursor position and scrolls the text to make it visible.
- CursorInfo cursorInfo;
- GetCursorPosition( mEventData->mPrimaryCursorPosition,
- cursorInfo );
+ // Note: mUpdateAlignment is currently only needed for horizontal alignment
+ eventData->mUpdateAlignment = needFullAlignment;
- // Scroll first the text after delete ...
- if( mEventData->mScrollAfterDelete )
+ // Update the cursor if it's in editing mode
+ if(EventData::IsEditingState(eventData->mState))
{
- ScrollTextToMatchCursor( cursorInfo );
+ impl.ChangeState(EventData::EDITING);
+ eventData->mUpdateCursorPosition = true;
}
+ }
+}
- // ... then, text can be scrolled to make the cursor visible.
- if( mEventData->mScrollAfterUpdatePosition )
- {
- ScrollToMakePositionVisible( cursorInfo.primaryPosition );
- }
- mEventData->mScrollAfterUpdatePosition = false;
- mEventData->mScrollAfterDelete = false;
+} // unnamed Namespace
+
+EventData::EventData(DecoratorPtr decorator, InputMethodContext& inputMethodContext)
+: mDecorator(decorator),
+ mInputMethodContext(inputMethodContext),
+ mPlaceholderFont(nullptr),
+ mPlaceholderTextActive(),
+ mPlaceholderTextInactive(),
+ mPlaceholderTextColor(0.8f, 0.8f, 0.8f, 0.8f), // This color has been published in the Public API (placeholder-properties.h).
+ mEventQueue(),
+ mInputStyleChangedQueue(),
+ mPreviousState(INACTIVE),
+ mState(INACTIVE),
+ mPrimaryCursorPosition(0u),
+ mLeftSelectionPosition(0u),
+ mRightSelectionPosition(0u),
+ mPreEditStartPosition(0u),
+ mPreEditLength(0u),
+ mCursorHookPositionX(0.f),
+ mDoubleTapAction(Controller::NoTextTap::NO_ACTION),
+ mLongPressAction(Controller::NoTextTap::SHOW_SELECTION_POPUP),
+ mIsShowingPlaceholderText(false),
+ mPreEditFlag(false),
+ mDecoratorUpdated(false),
+ mCursorBlinkEnabled(true),
+ mGrabHandleEnabled(true),
+ mGrabHandlePopupEnabled(true),
+ mSelectionEnabled(true),
+ mUpdateCursorHookPosition(false),
+ mUpdateCursorPosition(false),
+ mUpdateGrabHandlePosition(false),
+ mUpdateLeftSelectionPosition(false),
+ mUpdateRightSelectionPosition(false),
+ mIsLeftHandleSelected(false),
+ mIsRightHandleSelected(false),
+ mUpdateHighlightBox(false),
+ mScrollAfterUpdatePosition(false),
+ mScrollAfterDelete(false),
+ mAllTextSelected(false),
+ mUpdateInputStyle(false),
+ mPasswordInput(false),
+ mCheckScrollAmount(false),
+ mIsPlaceholderPixelSize(false),
+ mIsPlaceholderElideEnabled(false),
+ mPlaceholderEllipsisFlag(false),
+ mShiftSelectionFlag(true),
+ mUpdateAlignment(false),
+ mEditingEnabled(true)
+{
+}
- UpdateCursorPosition( cursorInfo );
+bool Controller::Impl::ProcessInputEvents()
+{
+ return ControllerImplEventHandler::ProcessInputEvents(*this);
+}
- mEventData->mDecoratorUpdated = true;
- mEventData->mUpdateCursorPosition = false;
- }
- else
+void Controller::Impl::NotifyInputMethodContext()
+{
+ if(mEventData && mEventData->mInputMethodContext)
{
- bool leftScroll = false;
- bool rightScroll = false;
+ CharacterIndex cursorPosition = GetLogicalCursorPosition();
- CursorInfo leftHandleInfo;
- CursorInfo rightHandleInfo;
+ const Length numberOfWhiteSpaces = GetNumberOfWhiteSpaces(0u);
- if( mEventData->mUpdateLeftSelectionPosition )
+ // Update the cursor position by removing the initial white spaces.
+ if(cursorPosition < numberOfWhiteSpaces)
{
- GetCursorPosition( mEventData->mLeftSelectionPosition,
- leftHandleInfo );
-
- if( mEventData->mScrollAfterUpdatePosition )
- {
- ScrollToMakePositionVisible( leftHandleInfo.primaryPosition );
- leftScroll = true;
- }
+ cursorPosition = 0u;
}
-
- if( mEventData->mUpdateRightSelectionPosition )
+ else
{
- GetCursorPosition( mEventData->mRightSelectionPosition,
- rightHandleInfo );
-
- if( mEventData->mScrollAfterUpdatePosition )
- {
- ScrollToMakePositionVisible( rightHandleInfo.primaryPosition );
- rightScroll = true;
- }
+ cursorPosition -= numberOfWhiteSpaces;
}
- if( mEventData->mUpdateLeftSelectionPosition )
- {
- UpdateSelectionHandle( LEFT_SELECTION_HANDLE,
- leftHandleInfo );
+ mEventData->mInputMethodContext.SetCursorPosition(cursorPosition);
+ mEventData->mInputMethodContext.NotifyCursorPosition();
+ }
+}
- SetPopupButtons();
- mEventData->mDecoratorUpdated = true;
- }
+void Controller::Impl::NotifyInputMethodContextMultiLineStatus()
+{
+ if(mEventData && mEventData->mInputMethodContext)
+ {
+ Text::Layout::Engine::Type layout = mLayoutEngine.GetLayout();
+ mEventData->mInputMethodContext.NotifyTextInputMultiLine(layout == Text::Layout::Engine::MULTI_LINE_BOX);
+ }
+}
- if( mEventData->mUpdateRightSelectionPosition )
- {
- UpdateSelectionHandle( RIGHT_SELECTION_HANDLE,
- rightHandleInfo );
+CharacterIndex Controller::Impl::GetLogicalCursorPosition() const
+{
+ CharacterIndex cursorPosition = 0u;
- SetPopupButtons();
- mEventData->mDecoratorUpdated = true;
+ if(mEventData)
+ {
+ if((EventData::SELECTING == mEventData->mState) ||
+ (EventData::SELECTION_HANDLE_PANNING == mEventData->mState))
+ {
+ cursorPosition = std::min(mEventData->mRightSelectionPosition, mEventData->mLeftSelectionPosition);
}
-
- if( mEventData->mUpdateLeftSelectionPosition || mEventData->mUpdateRightSelectionPosition )
+ else
{
- RepositionSelectionHandles();
-
- mEventData->mUpdateLeftSelectionPosition = false;
- mEventData->mUpdateRightSelectionPosition = false;
+ cursorPosition = mEventData->mPrimaryCursorPosition;
}
+ }
+
+ return cursorPosition;
+}
+
+Length Controller::Impl::GetNumberOfWhiteSpaces(CharacterIndex index) const
+{
+ Length numberOfWhiteSpaces = 0u;
- if( leftScroll || rightScroll )
+ // Get the buffer to the text.
+ Character* utf32CharacterBuffer = mModel->mLogicalModel->mText.Begin();
+
+ const Length totalNumberOfCharacters = mModel->mLogicalModel->mText.Count();
+ for(; index < totalNumberOfCharacters; ++index, ++numberOfWhiteSpaces)
+ {
+ if(!TextAbstraction::IsWhiteSpace(*(utf32CharacterBuffer + index)))
{
- mEventData->mScrollAfterUpdatePosition = false;
+ break;
}
}
- if( mEventData->mUpdateInputStyle )
+ return numberOfWhiteSpaces;
+}
+
+void Controller::Impl::GetText(std::string& text) const
+{
+ if(!IsShowingPlaceholderText())
+ {
+ // Retrieves the text string.
+ GetText(0u, text);
+ }
+ else
{
- // Set the default style first.
- RetrieveDefaultInputStyle( mEventData->mInputStyle );
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::GetText %p empty (but showing placeholder)\n", this);
+ }
+}
- // Get the character index from the cursor index.
- const CharacterIndex styleIndex = ( mEventData->mPrimaryCursorPosition > 0u ) ? mEventData->mPrimaryCursorPosition - 1u : 0u;
+void Controller::Impl::GetText(CharacterIndex index, std::string& text) const
+{
+ // Get the total number of characters.
+ Length numberOfCharacters = mModel->mLogicalModel->mText.Count();
- // Retrieve the style from the style runs stored in the logical model.
- mLogicalModel->RetrieveStyle( styleIndex, mEventData->mInputStyle );
+ // Retrieve the text.
+ if(0u != numberOfCharacters)
+ {
+ Utf32ToUtf8(mModel->mLogicalModel->mText.Begin() + index, numberOfCharacters - index, text);
+ }
+}
- mEventData->mUpdateInputStyle = false;
+Dali::LayoutDirection::Type Controller::Impl::GetLayoutDirection(Dali::Actor& actor) const
+{
+ if(mModel->mMatchLayoutDirection == DevelText::MatchLayoutDirection::LOCALE ||
+ (mModel->mMatchLayoutDirection == DevelText::MatchLayoutDirection::INHERIT && !mIsLayoutDirectionChanged))
+ {
+ Window window = DevelWindow::Get(actor);
+ return static_cast<Dali::LayoutDirection::Type>(window ? window.GetRootLayer().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>() : LayoutDirection::LEFT_TO_RIGHT);
}
+ else
+ {
+ return static_cast<Dali::LayoutDirection::Type>(actor.GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
+ }
+}
+
+Toolkit::DevelText::TextDirection::Type Controller::Impl::GetTextDirection()
+{
+ if(mUpdateTextDirection)
+ {
+ // Operations that can be done only once until the text changes.
+ const OperationsMask onlyOnceOperations = static_cast<OperationsMask>(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.
+ mTextUpdateInfo.mParagraphCharacterIndex = 0u;
+ mTextUpdateInfo.mRequestedNumberOfCharacters = mModel->mLogicalModel->mText.Count();
- mEventData->mEventQueue.clear();
+ // Make sure the model is up-to-date before layouting
+ UpdateModel(onlyOnceOperations);
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::ProcessInputEvents\n" );
+ Vector3 naturalSize;
+ Relayouter::DoRelayout(*this,
+ Size(MAX_FLOAT, MAX_FLOAT),
+ static_cast<OperationsMask>(onlyOnceOperations |
+ LAYOUT | REORDER | UPDATE_DIRECTION),
+ naturalSize.GetVectorXY());
- const bool decoratorUpdated = mEventData->mDecoratorUpdated;
- mEventData->mDecoratorUpdated = false;
+ // Do not do again the only once operations.
+ mOperationsPending = static_cast<OperationsMask>(mOperationsPending & ~onlyOnceOperations);
- return decoratorUpdated;
+ // Clear the update info. This info will be set the next time the text is updated.
+ mTextUpdateInfo.Clear();
+
+ // FullRelayoutNeeded should be true because DoRelayout is MAX_FLOAT, MAX_FLOAT.
+ mTextUpdateInfo.mFullRelayoutNeeded = true;
+
+ mUpdateTextDirection = false;
+ }
+
+ return mIsTextDirectionRTL ? Toolkit::DevelText::TextDirection::RIGHT_TO_LEFT : Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT;
}
-void Controller::Impl::CalculateTextUpdateIndices( Length& numberOfCharacters )
+void Controller::Impl::CalculateTextUpdateIndices(Length& numberOfCharacters)
{
mTextUpdateInfo.mParagraphCharacterIndex = 0u;
- mTextUpdateInfo.mStartGlyphIndex = 0u;
- mTextUpdateInfo.mStartLineIndex = 0u;
- numberOfCharacters = 0u;
+ mTextUpdateInfo.mStartGlyphIndex = 0u;
+ mTextUpdateInfo.mStartLineIndex = 0u;
+ numberOfCharacters = 0u;
- const Length numberOfParagraphs = mLogicalModel->mParagraphInfo.Count();
- if( 0u == numberOfParagraphs )
+ const Length numberOfParagraphs = mModel->mLogicalModel->mParagraphInfo.Count();
+ if(0u == numberOfParagraphs)
{
mTextUpdateInfo.mParagraphCharacterIndex = 0u;
- numberOfCharacters = 0u;
+ numberOfCharacters = 0u;
mTextUpdateInfo.mRequestedNumberOfCharacters = mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
// Find the paragraphs to be updated.
Vector<ParagraphRunIndex> paragraphsToBeUpdated;
- if( mTextUpdateInfo.mCharacterIndex >= mTextUpdateInfo.mPreviousNumberOfCharacters )
+ if(mTextUpdateInfo.mCharacterIndex >= mTextUpdateInfo.mPreviousNumberOfCharacters)
{
// Text is being added at the end of the current text.
- if( mTextUpdateInfo.mIsLastCharacterNewParagraph )
+ if(mTextUpdateInfo.mIsLastCharacterNewParagraph)
{
// Text is being added in a new paragraph after the last character of the text.
- mTextUpdateInfo.mParagraphCharacterIndex = mTextUpdateInfo.mPreviousNumberOfCharacters;
- numberOfCharacters = 0u;
+ mTextUpdateInfo.mParagraphCharacterIndex = mTextUpdateInfo.mPreviousNumberOfCharacters;
+ numberOfCharacters = 0u;
mTextUpdateInfo.mRequestedNumberOfCharacters = mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
- mTextUpdateInfo.mStartGlyphIndex = mVisualModel->mGlyphs.Count();
- mTextUpdateInfo.mStartLineIndex = mVisualModel->mLines.Count() - 1u;
+ mTextUpdateInfo.mStartGlyphIndex = mModel->mVisualModel->mGlyphs.Count();
+ mTextUpdateInfo.mStartLineIndex = mModel->mVisualModel->mLines.Count() - 1u;
// Nothing else to do;
return;
}
- paragraphsToBeUpdated.PushBack( numberOfParagraphs - 1u );
+ paragraphsToBeUpdated.PushBack(numberOfParagraphs - 1u);
}
else
{
Length numberOfCharactersToUpdate = 0u;
- if( mTextUpdateInfo.mFullRelayoutNeeded )
+ if(mTextUpdateInfo.mFullRelayoutNeeded)
{
numberOfCharactersToUpdate = mTextUpdateInfo.mPreviousNumberOfCharacters;
}
else
{
- numberOfCharactersToUpdate = ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) ? mTextUpdateInfo.mNumberOfCharactersToRemove : 1u;
+ numberOfCharactersToUpdate = (mTextUpdateInfo.mNumberOfCharactersToRemove > 0u) ? mTextUpdateInfo.mNumberOfCharactersToRemove : 1u;
}
- mLogicalModel->FindParagraphs( mTextUpdateInfo.mCharacterIndex,
- numberOfCharactersToUpdate,
- paragraphsToBeUpdated );
+ mModel->mLogicalModel->FindParagraphs(mTextUpdateInfo.mCharacterIndex,
+ numberOfCharactersToUpdate,
+ paragraphsToBeUpdated);
}
- if( 0u != paragraphsToBeUpdated.Count() )
+ if(0u != paragraphsToBeUpdated.Count())
{
- const ParagraphRunIndex firstParagraphIndex = *( paragraphsToBeUpdated.Begin() );
- const ParagraphRun& firstParagraph = *( mLogicalModel->mParagraphInfo.Begin() + firstParagraphIndex );
- mTextUpdateInfo.mParagraphCharacterIndex = firstParagraph.characterRun.characterIndex;
+ const ParagraphRunIndex firstParagraphIndex = *(paragraphsToBeUpdated.Begin());
+ const ParagraphRun& firstParagraph = *(mModel->mLogicalModel->mParagraphInfo.Begin() + firstParagraphIndex);
+ mTextUpdateInfo.mParagraphCharacterIndex = firstParagraph.characterRun.characterIndex;
- ParagraphRunIndex lastParagraphIndex = *( paragraphsToBeUpdated.End() - 1u );
- const ParagraphRun& lastParagraph = *( mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex );
+ ParagraphRunIndex lastParagraphIndex = *(paragraphsToBeUpdated.End() - 1u);
+ const ParagraphRun& lastParagraph = *(mModel->mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex);
- if( ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) && // Some character are removed.
- ( lastParagraphIndex < numberOfParagraphs - 1u ) && // There is a next paragraph.
- ( ( lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters ) == // The last removed character is the new paragraph character.
- ( mTextUpdateInfo.mCharacterIndex + mTextUpdateInfo.mNumberOfCharactersToRemove ) ) )
+ if((mTextUpdateInfo.mNumberOfCharactersToRemove > 0u) && // Some character are removed.
+ (lastParagraphIndex < numberOfParagraphs - 1u) && // There is a next paragraph.
+ ((lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters) == // The last removed character is the new paragraph character.
+ (mTextUpdateInfo.mCharacterIndex + mTextUpdateInfo.mNumberOfCharactersToRemove)))
{
// The new paragraph character of the last updated paragraph has been removed so is going to be merged with the next one.
- const ParagraphRun& lastParagraph = *( mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex + 1u );
+ const ParagraphRun& lastParagraph = *(mModel->mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex + 1u);
numberOfCharacters = lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters - mTextUpdateInfo.mParagraphCharacterIndex;
}
}
mTextUpdateInfo.mRequestedNumberOfCharacters = numberOfCharacters + mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
- mTextUpdateInfo.mStartGlyphIndex = *( mVisualModel->mCharactersToGlyph.Begin() + mTextUpdateInfo.mParagraphCharacterIndex );
+ mTextUpdateInfo.mStartGlyphIndex = *(mModel->mVisualModel->mCharactersToGlyph.Begin() + mTextUpdateInfo.mParagraphCharacterIndex);
}
-void Controller::Impl::ClearFullModelData( OperationsMask operations )
+void Controller::Impl::ClearModelData(CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations)
{
- if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
- {
- mLogicalModel->mLineBreakInfo.Clear();
- mLogicalModel->mParagraphInfo.Clear();
- }
+ ControllerImplDataClearer::ClearModelData(*this, startIndex, endIndex, operations);
+}
- if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) )
- {
- mLogicalModel->mLineBreakInfo.Clear();
- }
+bool Controller::Impl::UpdateModel(OperationsMask operationsRequired)
+{
+ return ControllerImplModelUpdater::Update(*this, operationsRequired);
+}
+
+void Controller::Impl::RetrieveDefaultInputStyle(InputStyle& inputStyle)
+{
+ SetDefaultInputStyle(inputStyle, mFontDefaults, mTextColor);
+}
- if( NO_OPERATION != ( GET_SCRIPTS & operations ) )
+float Controller::Impl::GetDefaultFontLineHeight()
+{
+ FontId defaultFontId = 0u;
+ if(nullptr == mFontDefaults)
{
- mLogicalModel->mScriptRuns.Clear();
+ TextAbstraction::FontDescription fontDescription;
+ defaultFontId = mFontClient.GetFontId(fontDescription, TextAbstraction::FontClient::DEFAULT_POINT_SIZE * GetFontSizeScale());
}
-
- if( NO_OPERATION != ( VALIDATE_FONTS & operations ) )
+ else
{
- mLogicalModel->mFontRuns.Clear();
+ defaultFontId = mFontDefaults->GetFontId(mFontClient, mFontDefaults->mDefaultPointSize * GetFontSizeScale());
}
- if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() )
- {
- if( NO_OPERATION != ( BIDI_INFO & operations ) )
- {
- mLogicalModel->mBidirectionalParagraphInfo.Clear();
- mLogicalModel->mCharacterDirections.Clear();
- }
+ Text::FontMetrics fontMetrics;
+ mMetrics->GetFontMetrics(defaultFontId, fontMetrics);
- 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(),
- endIt = mLogicalModel->mBidirectionalLineInfo.End();
- it != endIt;
- ++it )
- {
- BidirectionalLineInfoRun& bidiLineInfo = *it;
+ return (fontMetrics.ascender - fontMetrics.descender);
+}
- free( bidiLineInfo.visualToLogicalMap );
- bidiLineInfo.visualToLogicalMap = NULL;
- }
- mLogicalModel->mBidirectionalLineInfo.Clear();
- }
+bool Controller::Impl::SetDefaultLineSpacing(float lineSpacing)
+{
+ if(std::fabs(lineSpacing - mLayoutEngine.GetDefaultLineSpacing()) > Math::MACHINE_EPSILON_1000)
+ {
+ mLayoutEngine.SetDefaultLineSpacing(lineSpacing);
+
+ RelayoutAllCharacters();
+ return true;
}
+ return false;
+}
- if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
+bool Controller::Impl::SetDefaultLineSize(float lineSize)
+{
+ if(std::fabs(lineSize - mLayoutEngine.GetDefaultLineSize()) > Math::MACHINE_EPSILON_1000)
{
- mVisualModel->mGlyphs.Clear();
- mVisualModel->mGlyphsToCharacters.Clear();
- mVisualModel->mCharactersToGlyph.Clear();
- mVisualModel->mCharactersPerGlyph.Clear();
- mVisualModel->mGlyphsPerCharacter.Clear();
- mVisualModel->mGlyphPositions.Clear();
+ mLayoutEngine.SetDefaultLineSize(lineSize);
+
+ RelayoutAllCharacters();
+ return true;
}
+ return false;
+}
- if( NO_OPERATION != ( LAYOUT & operations ) )
+bool Controller::Impl::SetRelativeLineSize(float relativeLineSize)
+{
+ if(std::fabs(relativeLineSize - GetRelativeLineSize()) > Math::MACHINE_EPSILON_1000)
{
- mVisualModel->mLines.Clear();
+ mLayoutEngine.SetRelativeLineSize(relativeLineSize);
+
+ RelayoutAllCharacters();
+ return true;
}
+ return false;
+}
+
+float Controller::Impl::GetRelativeLineSize()
+{
+ return mLayoutEngine.GetRelativeLineSize();
+}
- if( NO_OPERATION != ( COLOR & operations ) )
+string Controller::Impl::GetSelectedText()
+{
+ string text;
+ if(EventData::SELECTING == mEventData->mState)
{
- mVisualModel->mColorIndices.Clear();
+ RetrieveSelection(text, false);
}
+ return text;
}
-void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations )
+string Controller::Impl::CopyText()
{
- const CharacterIndex endIndexPlusOne = endIndex + 1u;
+ string text;
+ RetrieveSelection(text, false);
+ SendSelectionToClipboard(false); // Text not modified
- if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
- {
- // Clear the line break info.
- LineBreakInfo* lineBreakInfoBuffer = mLogicalModel->mLineBreakInfo.Begin();
+ mEventData->mUpdateCursorPosition = true;
- mLogicalModel->mLineBreakInfo.Erase( lineBreakInfoBuffer + startIndex,
- lineBreakInfoBuffer + endIndexPlusOne );
+ RequestRelayout(); // Cursor, Handles, Selection Highlight, Popup
- // Clear the paragraphs.
- ClearCharacterRuns( startIndex,
- endIndex,
- mLogicalModel->mParagraphInfo );
- }
+ return text;
+}
- if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) )
- {
- // Clear the word break info.
- WordBreakInfo* wordBreakInfoBuffer = mLogicalModel->mWordBreakInfo.Begin();
+string Controller::Impl::CutText()
+{
+ string text;
+ RetrieveSelection(text, false);
- mLogicalModel->mWordBreakInfo.Erase( wordBreakInfoBuffer + startIndex,
- wordBreakInfoBuffer + endIndexPlusOne );
+ if(!IsEditable())
+ {
+ return EMPTY_STRING;
}
- if( NO_OPERATION != ( GET_SCRIPTS & operations ) )
+ SendSelectionToClipboard(true); // Synchronous call to modify text
+ mOperationsPending = ALL_OPERATIONS;
+
+ if((0u != mModel->mLogicalModel->mText.Count()) ||
+ !IsPlaceholderAvailable())
+ {
+ QueueModifyEvent(ModifyEvent::TEXT_DELETED);
+ }
+ else
{
- // Clear the scripts.
- ClearCharacterRuns( startIndex,
- endIndex,
- mLogicalModel->mScriptRuns );
+ PlaceholderHandler::ShowPlaceholderText(*this);
}
- if( NO_OPERATION != ( VALIDATE_FONTS & operations ) )
+ mEventData->mUpdateCursorPosition = true;
+ mEventData->mScrollAfterDelete = true;
+
+ RequestRelayout();
+
+ if(nullptr != mEditableControlInterface)
{
- // Clear the fonts.
- ClearCharacterRuns( startIndex,
- endIndex,
- mLogicalModel->mFontRuns );
+ mEditableControlInterface->TextChanged(true);
}
+ return text;
+}
- if( 0u != mLogicalModel->mBidirectionalParagraphInfo.Count() )
+void Controller::Impl::SetTextSelectionRange(const uint32_t* pStart, const uint32_t* pEnd)
+{
+ if(nullptr == mEventData)
{
- if( NO_OPERATION != ( BIDI_INFO & operations ) )
- {
- // Clear the bidirectional paragraph info.
- ClearCharacterRuns( startIndex,
- endIndex,
- mLogicalModel->mBidirectionalParagraphInfo );
+ // Nothing to do if there is no text.
+ return;
+ }
- // Clear the character's directions.
- CharacterDirection* characterDirectionsBuffer = mLogicalModel->mCharacterDirections.Begin();
+ if(mEventData->mSelectionEnabled && (pStart || pEnd))
+ {
+ uint32_t length = static_cast<uint32_t>(mModel->mLogicalModel->mText.Count());
+ uint32_t oldStart = mEventData->mLeftSelectionPosition;
+ uint32_t oldEnd = mEventData->mRightSelectionPosition;
- mLogicalModel->mCharacterDirections.Erase( characterDirectionsBuffer + startIndex,
- characterDirectionsBuffer + endIndexPlusOne );
+ if(pStart)
+ {
+ mEventData->mLeftSelectionPosition = std::min(*pStart, length);
}
-
- if( NO_OPERATION != ( REORDER & operations ) )
+ if(pEnd)
{
- uint32_t startRemoveIndex = mLogicalModel->mBidirectionalLineInfo.Count();
- uint32_t endRemoveIndex = startRemoveIndex;
- ClearCharacterRuns( startIndex,
- endIndex,
- mLogicalModel->mBidirectionalLineInfo,
- startRemoveIndex,
- endRemoveIndex );
-
- BidirectionalLineInfoRun* bidirectionalLineInfoBuffer = mLogicalModel->mBidirectionalLineInfo.Begin();
-
- // Free the allocated memory used to store the conversion table in the bidirectional line info run.
- for( Vector<BidirectionalLineInfoRun>::Iterator it = bidirectionalLineInfoBuffer + startRemoveIndex,
- endIt = bidirectionalLineInfoBuffer + endRemoveIndex;
- it != endIt;
- ++it )
- {
- BidirectionalLineInfoRun& bidiLineInfo = *it;
-
- free( bidiLineInfo.visualToLogicalMap );
- bidiLineInfo.visualToLogicalMap = NULL;
- }
-
- mLogicalModel->mBidirectionalLineInfo.Erase( bidirectionalLineInfoBuffer + startRemoveIndex,
- bidirectionalLineInfoBuffer + endRemoveIndex );
+ mEventData->mRightSelectionPosition = std::min(*pEnd, length);
}
- }
-}
-
-void Controller::Impl::ClearGlyphModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations )
-{
- const CharacterIndex endIndexPlusOne = endIndex + 1u;
- const Length numberOfCharactersRemoved = endIndexPlusOne - startIndex;
-
- // 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 endGlyphIndexPlusOne = *( charactersToGlyphBuffer + endIndex ) + *( glyphsPerCharacterBuffer + endIndex );
- const Length numberOfGlyphsRemoved = endGlyphIndexPlusOne - mTextUpdateInfo.mStartGlyphIndex;
-
- 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 )
+ if(mEventData->mLeftSelectionPosition == mEventData->mRightSelectionPosition)
{
- CharacterIndex& index = *it;
- index -= numberOfGlyphsRemoved;
+ ChangeState(EventData::EDITING);
+ mEventData->mPrimaryCursorPosition = mEventData->mLeftSelectionPosition = mEventData->mRightSelectionPosition;
+ mEventData->mUpdateCursorPosition = true;
}
-
- // 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 buffer.
- GlyphInfo* glyphsBuffer = mVisualModel->mGlyphs.Begin();
- mVisualModel->mGlyphs.Erase( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex,
- glyphsBuffer + endGlyphIndexPlusOne );
-
- 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 )
+ else
{
- CharacterIndex& index = *it;
- index -= numberOfCharactersRemoved;
+ ChangeState(EventData::SELECTING);
+ mEventData->mUpdateHighlightBox = true;
+ mEventData->mUpdateLeftSelectionPosition = true;
+ mEventData->mUpdateRightSelectionPosition = true;
}
- // 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 positions buffer.
- Vector2* positionsBuffer = mVisualModel->mGlyphPositions.Begin();
- mVisualModel->mGlyphPositions.Erase( positionsBuffer + mTextUpdateInfo.mStartGlyphIndex,
- positionsBuffer + endGlyphIndexPlusOne );
- }
-
- 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.
- 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;
-
- LineRun* linesBuffer = mVisualModel->mLines.Begin();
- mVisualModel->mLines.Erase( linesBuffer + startRemoveIndex,
- linesBuffer + endRemoveIndex );
- }
-
- if( NO_OPERATION != ( COLOR & operations ) )
- {
- if( 0u != mVisualModel->mColorIndices.Count() )
+ if(mSelectableControlInterface != nullptr)
{
- ColorIndex* colorIndexBuffer = mVisualModel->mColorIndices.Begin();
- mVisualModel->mColorIndices.Erase( colorIndexBuffer + mTextUpdateInfo.mStartGlyphIndex,
- colorIndexBuffer + endGlyphIndexPlusOne );
+ mSelectableControlInterface->SelectionChanged(oldStart, oldEnd, mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition);
}
}
}
-void Controller::Impl::ClearModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations )
+CharacterIndex Controller::Impl::GetPrimaryCursorPosition() const
{
- if( mTextUpdateInfo.mClearAll ||
- ( ( 0u == startIndex ) &&
- ( mTextUpdateInfo.mPreviousNumberOfCharacters == endIndex + 1u ) ) )
+ if(nullptr == mEventData)
{
- ClearFullModelData( operations );
- }
- else
- {
- // Clear the model data related with characters.
- ClearCharacterModelData( startIndex, endIndex, operations );
-
- // Clear the model data related with glyphs.
- ClearGlyphModelData( startIndex, endIndex, operations );
+ return 0;
}
-
- // The estimated number of lines. Used to avoid reallocations when layouting.
- mTextUpdateInfo.mEstimatedNumberOfLines = std::max( mVisualModel->mLines.Count(), mLogicalModel->mParagraphInfo.Count() );
-
- mVisualModel->ClearCaches();
+ return mEventData->mPrimaryCursorPosition;
}
-bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
+bool Controller::Impl::SetPrimaryCursorPosition(CharacterIndex index, bool focused)
{
- DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::UpdateModel\n" );
-
- // Calculate the operations to be done.
- const OperationsMask operations = static_cast<OperationsMask>( mOperationsPending & operationsRequired );
-
- if( NO_OPERATION == operations )
+ if(nullptr == mEventData)
{
- // Nothing to do if no operations are pending and required.
+ // Nothing to do if there is no text.
return false;
}
- Vector<Character>& utf32Characters = mLogicalModel->mText;
-
- const Length numberOfCharacters = utf32Characters.Count();
-
- // Index to the first character of the first paragraph to be updated.
- CharacterIndex startIndex = 0u;
- // Number of characters of the paragraphs to be removed.
- Length paragraphCharacters = 0u;
-
- CalculateTextUpdateIndices( paragraphCharacters );
- startIndex = mTextUpdateInfo.mParagraphCharacterIndex;
-
- if( mTextUpdateInfo.mClearAll ||
- ( 0u != paragraphCharacters ) )
+ if(mEventData->mPrimaryCursorPosition == index && mEventData->mState != EventData::SELECTING)
{
- ClearModelData( startIndex, startIndex + ( ( paragraphCharacters > 0u ) ? paragraphCharacters - 1u : 0u ), operations );
+ // Nothing for same cursor position.
+ return false;
}
- mTextUpdateInfo.mClearAll = false;
-
- // Whether the model is updated.
- bool updated = false;
-
- Vector<LineBreakInfo>& lineBreakInfo = mLogicalModel->mLineBreakInfo;
- const Length requestedNumberOfCharacters = mTextUpdateInfo.mRequestedNumberOfCharacters;
-
- if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
+ uint32_t length = static_cast<uint32_t>(mModel->mLogicalModel->mText.Count());
+ uint32_t oldCursorPos = mEventData->mPrimaryCursorPosition;
+ mEventData->mPrimaryCursorPosition = std::min(index, length);
+ // If there is no focus, only the value is updated.
+ if(focused)
{
- // 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'.
- // It's also used to layout the text (where it should be a new line) or to shape the text (text in different lines
- // is not shaped together).
- lineBreakInfo.Resize( numberOfCharacters, TextAbstraction::LINE_NO_BREAK );
+ bool wasInSelectingState = mEventData->mState == EventData::SELECTING;
+ uint32_t oldStart = mEventData->mLeftSelectionPosition;
+ uint32_t oldEnd = mEventData->mRightSelectionPosition;
+ ChangeState(EventData::EDITING);
+ mEventData->mLeftSelectionPosition = mEventData->mRightSelectionPosition = mEventData->mPrimaryCursorPosition;
+ mEventData->mUpdateCursorPosition = true;
- SetLineBreakInfo( utf32Characters,
- startIndex,
- requestedNumberOfCharacters,
- lineBreakInfo );
+ if(mSelectableControlInterface != nullptr && wasInSelectingState)
+ {
+ mSelectableControlInterface->SelectionChanged(oldStart, oldEnd, mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition);
+ }
- // Create the paragraph info.
- mLogicalModel->CreateParagraphInfo( startIndex,
- requestedNumberOfCharacters );
- updated = true;
+ ScrollTextToMatchCursor();
}
- Vector<WordBreakInfo>& wordBreakInfo = mLogicalModel->mWordBreakInfo;
- if( NO_OPERATION != ( GET_WORD_BREAKS & operations ) )
+ if(nullptr != mEditableControlInterface)
{
- // 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 );
-
- SetWordBreakInfo( utf32Characters,
- startIndex,
- requestedNumberOfCharacters,
- wordBreakInfo );
- updated = true;
+ mEditableControlInterface->CursorPositionChanged(oldCursorPos, mEventData->mPrimaryCursorPosition);
}
- const bool getScripts = NO_OPERATION != ( GET_SCRIPTS & operations );
- const bool validateFonts = NO_OPERATION != ( VALIDATE_FONTS & operations );
+ return true;
+}
- Vector<ScriptRun>& scripts = mLogicalModel->mScriptRuns;
- Vector<FontRun>& validFonts = mLogicalModel->mFontRuns;
+Uint32Pair Controller::Impl::GetTextSelectionRange() const
+{
+ Uint32Pair range;
- if( getScripts || validateFonts )
+ if(mEventData)
{
- // Validates the fonts assigned by the application or assigns default ones.
- // It makes sure all the characters are going to be rendered by the correct font.
- MultilanguageSupport multilanguageSupport = MultilanguageSupport::Get();
+ range.first = mEventData->mLeftSelectionPosition;
+ range.second = mEventData->mRightSelectionPosition;
+ }
- if( getScripts )
- {
- // Retrieves the scripts used in the text.
- multilanguageSupport.SetScripts( utf32Characters,
- startIndex,
- requestedNumberOfCharacters,
- scripts );
- }
+ return range;
+}
- if( validateFonts )
- {
- // Validate the fonts set through the mark-up string.
- Vector<FontDescriptionRun>& fontDescriptionRuns = mLogicalModel->mFontDescriptionRuns;
-
- // Get the default font id.
- const FontId defaultFontId = ( NULL == mFontDefaults ) ? 0u : mFontDefaults->GetFontId( mFontClient );
-
- // Validates the fonts. If there is a character with no assigned font it sets a default one.
- // After this call, fonts are validated.
- multilanguageSupport.ValidateFonts( utf32Characters,
- scripts,
- fontDescriptionRuns,
- defaultFontId,
- startIndex,
- requestedNumberOfCharacters,
- validFonts );
- }
- updated = true;
- }
+bool Controller::Impl::IsEditable() const
+{
+ return mEventData && mEventData->mEditingEnabled;
+}
- Vector<Character> mirroredUtf32Characters;
- bool textMirrored = false;
- const Length numberOfParagraphs = mLogicalModel->mParagraphInfo.Count();
- if( NO_OPERATION != ( BIDI_INFO & operations ) )
+void Controller::Impl::SetEditable(bool editable)
+{
+ if(mEventData)
{
- Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mLogicalModel->mBidirectionalParagraphInfo;
- bidirectionalInfo.Reserve( numberOfParagraphs );
-
- // Calculates the bidirectional info for the whole paragraph if it contains right to left scripts.
- SetBidirectionalInfo( utf32Characters,
- scripts,
- lineBreakInfo,
- startIndex,
- requestedNumberOfCharacters,
- bidirectionalInfo );
+ mEventData->mEditingEnabled = editable;
- if( 0u != bidirectionalInfo.Count() )
- {
- // Only set the character directions if there is right to left characters.
- Vector<CharacterDirection>& directions = mLogicalModel->mCharacterDirections;
- GetCharactersDirection( bidirectionalInfo,
- numberOfCharacters,
- startIndex,
- requestedNumberOfCharacters,
- directions );
-
- // This paragraph has right to left text. Some characters may need to be mirrored.
- // TODO: consider if the mirrored string can be stored as well.
-
- textMirrored = GetMirroredText( utf32Characters,
- directions,
- bidirectionalInfo,
- startIndex,
- requestedNumberOfCharacters,
- mirroredUtf32Characters );
- }
- else
+ if(mEventData->mDecorator)
{
- // There is no right to left characters. Clear the directions vector.
- mLogicalModel->mCharacterDirections.Clear();
+ bool decoratorEditable = editable && mIsUserInteractionEnabled;
+ mEventData->mDecorator->SetEditable(decoratorEditable);
}
- updated = true;
}
+}
- Vector<GlyphInfo>& glyphs = mVisualModel->mGlyphs;
- Vector<CharacterIndex>& glyphsToCharactersMap = mVisualModel->mGlyphsToCharacters;
- Vector<Length>& charactersPerGlyph = mVisualModel->mCharactersPerGlyph;
- Vector<GlyphIndex> newParagraphGlyphs;
- newParagraphGlyphs.Reserve( numberOfParagraphs );
+void Controller::Impl::UpdateAfterFontChange(const std::string& newDefaultFont)
+{
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Controller::UpdateAfterFontChange\n");
- const Length currentNumberOfGlyphs = glyphs.Count();
- if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
+ if(!mFontDefaults->familyDefined) // If user defined font then should not update when system font changes
{
- const Vector<Character>& textToShape = textMirrored ? mirroredUtf32Characters : utf32Characters;
- // Shapes the text.
- ShapeText( textToShape,
- lineBreakInfo,
- scripts,
- validFonts,
- startIndex,
- mTextUpdateInfo.mStartGlyphIndex,
- requestedNumberOfCharacters,
- glyphs,
- glyphsToCharactersMap,
- charactersPerGlyph,
- newParagraphGlyphs );
-
- // 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;
- }
+ DALI_LOG_INFO(gLogFilter, Debug::Concise, "Controller::UpdateAfterFontChange newDefaultFont(%s)\n", newDefaultFont.c_str());
+ mFontDefaults->mFontDescription.family = newDefaultFont;
- const Length numberOfGlyphs = glyphs.Count() - currentNumberOfGlyphs;
+ ClearFontData();
- if( NO_OPERATION != ( GET_GLYPH_METRICS & operations ) )
- {
- GlyphInfo* glyphsBuffer = glyphs.Begin();
- mMetrics->GetGlyphMetrics( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex, numberOfGlyphs );
-
- // Update the width and advance of all new paragraph characters.
- for( Vector<GlyphIndex>::ConstIterator it = newParagraphGlyphs.Begin(), endIt = newParagraphGlyphs.End(); it != endIt; ++it )
- {
- const GlyphIndex index = *it;
- GlyphInfo& glyph = *( glyphsBuffer + index );
-
- glyph.xBearing = 0.f;
- glyph.width = 0.f;
- glyph.advance = 0.f;
- }
- updated = true;
+ RequestRelayout();
}
+}
- if( NO_OPERATION != ( COLOR & operations ) )
+void Controller::Impl::RetrieveSelection(std::string& selectedText, bool deleteAfterRetrieval)
+{
+ if(mEventData->mLeftSelectionPosition == mEventData->mRightSelectionPosition)
{
- // Set the color runs in glyphs.
- SetColorSegmentationInfo( mLogicalModel->mColorRuns,
- mVisualModel->mCharactersToGlyph,
- mVisualModel->mGlyphsPerCharacter,
- startIndex,
- mTextUpdateInfo.mStartGlyphIndex,
- requestedNumberOfCharacters,
- mVisualModel->mColors,
- mVisualModel->mColorIndices );
-
- updated = true;
+ // Nothing to select if handles are in the same place.
+ selectedText.clear();
+ return;
}
- if( ( NULL != mEventData ) &&
- mEventData->mPreEditFlag &&
- ( 0u != mVisualModel->mCharactersToGlyph.Count() ) )
- {
- // Add the underline for the pre-edit text.
- const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin();
- const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin();
-
- const GlyphIndex glyphStart = *( charactersToGlyphBuffer + mEventData->mPreEditStartPosition );
- const CharacterIndex lastPreEditCharacter = mEventData->mPreEditStartPosition + ( ( mEventData->mPreEditLength > 0u ) ? mEventData->mPreEditLength - 1u : 0u );
- const Length numberOfGlyphsLastCharacter = *( glyphsPerCharacterBuffer + lastPreEditCharacter );
- const GlyphIndex glyphEnd = *( charactersToGlyphBuffer + lastPreEditCharacter ) + ( numberOfGlyphsLastCharacter > 1u ? numberOfGlyphsLastCharacter - 1u : 0u );
+ const bool handlesCrossed = mEventData->mLeftSelectionPosition > mEventData->mRightSelectionPosition;
- GlyphRun underlineRun;
- underlineRun.glyphIndex = glyphStart;
- underlineRun.numberOfGlyphs = 1u + glyphEnd - glyphStart;
+ //Get start and end position of selection
+ const CharacterIndex startOfSelectedText = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
+ const Length lengthOfSelectedText = (handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition) - startOfSelectedText;
- // TODO: At the moment the underline runs are only for pre-edit.
- mVisualModel->mUnderlineRuns.PushBack( underlineRun );
- }
+ Vector<Character>& utf32Characters = mModel->mLogicalModel->mText;
+ const Length numberOfCharacters = utf32Characters.Count();
- // The estimated number of lines. Used to avoid reallocations when layouting.
- mTextUpdateInfo.mEstimatedNumberOfLines = std::max( mVisualModel->mLines.Count(), mLogicalModel->mParagraphInfo.Count() );
+ // Validate the start and end selection points
+ if((startOfSelectedText + lengthOfSelectedText) <= numberOfCharacters)
+ {
+ //Get text as a UTF8 string
+ Utf32ToUtf8(&utf32Characters[startOfSelectedText], lengthOfSelectedText, selectedText);
- // Set the previous number of characters for the next time the text is updated.
- mTextUpdateInfo.mPreviousNumberOfCharacters = numberOfCharacters;
+ if(deleteAfterRetrieval) // Only delete text if copied successfully
+ {
+ // Keep a copy of the current input style.
+ InputStyle currentInputStyle;
+ currentInputStyle.Copy(mEventData->mInputStyle);
- return updated;
-}
+ // Set as input style the style of the first deleted character.
+ mModel->mLogicalModel->RetrieveStyle(startOfSelectedText, mEventData->mInputStyle);
-void Controller::Impl::RetrieveDefaultInputStyle( InputStyle& inputStyle )
-{
- // Sets the default text's color.
- inputStyle.textColor = mTextColor;
- inputStyle.isDefaultColor = true;
+ // Compare if the input style has changed.
+ const bool hasInputStyleChanged = !currentInputStyle.Equal(mEventData->mInputStyle);
- inputStyle.familyName.clear();
- inputStyle.weight = TextAbstraction::FontWeight::NORMAL;
- inputStyle.width = TextAbstraction::FontWidth::NORMAL;
- inputStyle.slant = TextAbstraction::FontSlant::NORMAL;
- inputStyle.size = 0.f;
+ if(hasInputStyleChanged)
+ {
+ const InputStyle::Mask styleChangedMask = currentInputStyle.GetInputStyleChangeMask(mEventData->mInputStyle);
+ // Queue the input style changed signal.
+ mEventData->mInputStyleChangedQueue.PushBack(styleChangedMask);
+ }
- inputStyle.familyDefined = false;
- inputStyle.weightDefined = false;
- inputStyle.widthDefined = false;
- inputStyle.slantDefined = false;
- inputStyle.sizeDefined = false;
+ mModel->mLogicalModel->UpdateTextStyleRuns(startOfSelectedText, -static_cast<int>(lengthOfSelectedText));
- // Sets the default font's family name, weight, width, slant and size.
- if( mFontDefaults )
- {
- if( mFontDefaults->familyDefined )
- {
- inputStyle.familyName = mFontDefaults->mFontDescription.family;
- inputStyle.familyDefined = true;
- }
+ // Mark the paragraphs to be updated.
+ if(Layout::Engine::SINGLE_LINE_BOX == mLayoutEngine.GetLayout())
+ {
+ mTextUpdateInfo.mCharacterIndex = 0;
+ mTextUpdateInfo.mNumberOfCharactersToRemove = mTextUpdateInfo.mPreviousNumberOfCharacters;
+ mTextUpdateInfo.mNumberOfCharactersToAdd = mTextUpdateInfo.mPreviousNumberOfCharacters - lengthOfSelectedText;
+ mTextUpdateInfo.mClearAll = true;
+ }
+ else
+ {
+ mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
+ mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
+ }
- if( mFontDefaults->weightDefined )
- {
- inputStyle.weight = mFontDefaults->mFontDescription.weight;
- inputStyle.weightDefined = true;
- }
+ // Delete text between handles
+ Vector<Character>::Iterator first = utf32Characters.Begin() + startOfSelectedText;
+ Vector<Character>::Iterator last = first + lengthOfSelectedText;
+ utf32Characters.Erase(first, last);
- if( mFontDefaults->widthDefined )
- {
- inputStyle.width = mFontDefaults->mFontDescription.width;
- inputStyle.widthDefined = true;
+ // Will show the cursor at the first character of the selection.
+ mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
}
-
- if( mFontDefaults->slantDefined )
+ else
{
- inputStyle.slant = mFontDefaults->mFontDescription.slant;
- inputStyle.slantDefined = true;
+ // Will show the cursor at the last character of the selection.
+ mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition;
}
- if( mFontDefaults->sizeDefined )
- {
- inputStyle.size = mFontDefaults->mDefaultPointSize;
- inputStyle.sizeDefined = true;
- }
+ mEventData->mDecoratorUpdated = true;
}
}
-float Controller::Impl::GetDefaultFontLineHeight()
+void Controller::Impl::SetSelection(int start, int end)
{
- FontId defaultFontId = 0u;
- if( NULL == mFontDefaults )
- {
- TextAbstraction::FontDescription fontDescription;
- defaultFontId = mFontClient.GetFontId( fontDescription );
- }
- else
+ uint32_t oldStart = mEventData->mLeftSelectionPosition;
+ uint32_t oldEnd = mEventData->mRightSelectionPosition;
+
+ mEventData->mLeftSelectionPosition = start;
+ mEventData->mRightSelectionPosition = end;
+ mEventData->mUpdateCursorPosition = true;
+
+ if(mSelectableControlInterface != nullptr)
{
- defaultFontId = mFontDefaults->GetFontId( mFontClient );
+ mSelectableControlInterface->SelectionChanged(oldStart, oldEnd, start, end);
}
+}
- Text::FontMetrics fontMetrics;
- mMetrics->GetFontMetrics( defaultFontId, fontMetrics );
-
- return( fontMetrics.ascender - fontMetrics.descender );
+std::pair<int, int> Controller::Impl::GetSelectionIndexes() const
+{
+ return {mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition};
}
-void Controller::Impl::OnCursorKeyEvent( const Event& event )
+void Controller::Impl::ShowClipboard()
{
- if( NULL == mEventData )
+ if(mClipboard)
{
- // Nothing to do if there is no text input.
- return;
+ mClipboard.ShowClipboard();
}
+}
- int keyCode = event.p1.mInt;
-
- if( Dali::DALI_KEY_CURSOR_LEFT == keyCode )
- {
- if( mEventData->mPrimaryCursorPosition > 0u )
- {
- mEventData->mPrimaryCursorPosition = CalculateNewCursorIndex( mEventData->mPrimaryCursorPosition - 1u );
- }
- }
- else if( Dali::DALI_KEY_CURSOR_RIGHT == keyCode )
- {
- if( mLogicalModel->mText.Count() > mEventData->mPrimaryCursorPosition )
- {
- mEventData->mPrimaryCursorPosition = CalculateNewCursorIndex( mEventData->mPrimaryCursorPosition );
- }
- }
- else if( Dali::DALI_KEY_CURSOR_UP == keyCode )
- {
- // TODO
- }
- else if( Dali::DALI_KEY_CURSOR_DOWN == keyCode )
+void Controller::Impl::HideClipboard()
+{
+ if(mClipboard && mClipboardHideEnabled)
{
- // TODO
+ mClipboard.HideClipboard();
}
-
- mEventData->mUpdateCursorPosition = true;
- mEventData->mUpdateInputStyle = true;
- mEventData->mScrollAfterUpdatePosition = true;
}
-void Controller::Impl::OnTapEvent( const Event& event )
+void Controller::Impl::SetClipboardHideEnable(bool enable)
{
- if( NULL != mEventData )
- {
- const unsigned int tapCount = event.p1.mUint;
-
- if( 1u == tapCount )
- {
- if( IsShowingRealText() )
- {
- const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x;
- const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y;
-
- mEventData->mPrimaryCursorPosition = Text::GetClosestCursorIndex( mVisualModel,
- mLogicalModel,
- mMetrics,
- xPosition,
- yPosition );
-
- // When the cursor position is changing, delay cursor blinking
- mEventData->mDecorator->DelayCursorBlink();
- }
- else
- {
- mEventData->mPrimaryCursorPosition = 0u;
- }
-
- mEventData->mUpdateCursorPosition = true;
- mEventData->mScrollAfterUpdatePosition = true;
- mEventData->mUpdateInputStyle = true;
-
- // Notify the cursor position to the imf manager.
- if( mEventData->mImfManager )
- {
- mEventData->mImfManager.SetCursorPosition( mEventData->mPrimaryCursorPosition );
- mEventData->mImfManager.NotifyCursorPosition();
- }
- }
- }
+ mClipboardHideEnabled = enable;
}
-void Controller::Impl::OnPanEvent( const Event& event )
+bool Controller::Impl::CopyStringToClipboard(const std::string& source)
{
- if( NULL == mEventData )
- {
- // Nothing to do if there is no text input.
- return;
- }
+ //Send string to clipboard
+ return (mClipboard && mClipboard.SetItem(source));
+}
- int state = event.p1.mInt;
+void Controller::Impl::SendSelectionToClipboard(bool deleteAfterSending)
+{
+ std::string selectedText;
+ RetrieveSelection(selectedText, deleteAfterSending);
+ CopyStringToClipboard(selectedText);
+ ChangeState(EventData::EDITING);
+}
- if( Gesture::Started == state ||
- Gesture::Continuing == state )
+void Controller::Impl::RequestGetTextFromClipboard()
+{
+ if(mClipboard)
{
- const Vector2& actualSize = mVisualModel->GetLayoutSize();
- const Vector2 currentScroll = mEventData->mScrollPosition;
-
- if( mEventData->mHorizontalScrollingEnabled )
- {
- const float displacementX = event.p2.mFloat;
- mEventData->mScrollPosition.x += displacementX;
-
- ClampHorizontalScroll( actualSize );
- }
-
- if( mEventData->mVerticalScrollingEnabled )
- {
- const float displacementY = event.p3.mFloat;
- mEventData->mScrollPosition.y += displacementY;
-
- ClampVerticalScroll( actualSize );
- }
-
- if( mEventData->mDecorator )
- {
- mEventData->mDecorator->UpdatePositions( mEventData->mScrollPosition - currentScroll );
- }
+ mClipboard.RequestItem();
}
}
-void Controller::Impl::OnLongPressEvent( const Event& event )
+void Controller::Impl::RepositionSelectionHandles()
{
- DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::OnLongPressEvent\n" );
-
- if( EventData::EDITING == mEventData->mState )
- {
- ChangeState ( EventData::EDITING_WITH_POPUP );
- mEventData->mDecoratorUpdated = true;
- }
+ SelectionHandleController::Reposition(*this);
+}
+void Controller::Impl::RepositionSelectionHandles(float visualX, float visualY, Controller::NoTextTap::Action action)
+{
+ SelectionHandleController::Reposition(*this, visualX, visualY, action);
}
-void Controller::Impl::OnHandleEvent( const Event& event )
+void Controller::Impl::SetPopupButtons()
{
- if( NULL == mEventData )
- {
- // Nothing to do if there is no text input.
- return;
- }
+ /**
+ * Sets the Popup buttons to be shown depending on State.
+ *
+ * If SELECTING : CUT & COPY + ( PASTE & CLIPBOARD if content available to paste )
+ *
+ * If EDITING_WITH_POPUP : SELECT & SELECT_ALL
+ */
- const unsigned int state = event.p1.mUint;
- const bool handleStopScrolling = ( HANDLE_STOP_SCROLLING == state );
+ bool isEditable = IsEditable();
+ TextSelectionPopup::Buttons buttonsToShow = TextSelectionPopup::NONE;
- if( HANDLE_PRESSED == state )
+ if(EventData::SELECTING == mEventData->mState)
{
- // The event.p2 and event.p3 are in decorator coords. Need to transforms to text coords.
- const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x;
- const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y;
-
- const CharacterIndex handleNewPosition = Text::GetClosestCursorIndex( mVisualModel,
- mLogicalModel,
- mMetrics,
- xPosition,
- yPosition );
-
- if( Event::GRAB_HANDLE_EVENT == event.type )
+ buttonsToShow = TextSelectionPopup::Buttons(TextSelectionPopup::COPY);
+ if(isEditable)
{
- ChangeState ( EventData::GRAB_HANDLE_PANNING );
-
- if( handleNewPosition != mEventData->mPrimaryCursorPosition )
- {
- mEventData->mPrimaryCursorPosition = handleNewPosition;
- mEventData->mUpdateCursorPosition = true;
- }
+ buttonsToShow = TextSelectionPopup::Buttons(buttonsToShow | TextSelectionPopup::CUT);
}
- else if( Event::LEFT_SELECTION_HANDLE_EVENT == event.type )
- {
- ChangeState ( EventData::SELECTION_HANDLE_PANNING );
- if( ( handleNewPosition != mEventData->mLeftSelectionPosition ) &&
- ( handleNewPosition != mEventData->mRightSelectionPosition ) )
+ if(!IsClipboardEmpty())
+ {
+ if(isEditable)
{
- mEventData->mLeftSelectionPosition = handleNewPosition;
-
- mEventData->mUpdateLeftSelectionPosition = true;
+ buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::PASTE));
}
+ buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::CLIPBOARD));
}
- else if( Event::RIGHT_SELECTION_HANDLE_EVENT == event.type )
- {
- ChangeState ( EventData::SELECTION_HANDLE_PANNING );
- if( ( handleNewPosition != mEventData->mRightSelectionPosition ) &&
- ( handleNewPosition != mEventData->mLeftSelectionPosition ) )
- {
- mEventData->mRightSelectionPosition = handleNewPosition;
-
- mEventData->mUpdateRightSelectionPosition = true;
- }
+ if(!mEventData->mAllTextSelected)
+ {
+ buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::SELECT_ALL));
}
- } // end ( HANDLE_PRESSED == state )
- else if( ( HANDLE_RELEASED == state ) ||
- handleStopScrolling )
+ }
+ else if(EventData::EDITING_WITH_POPUP == mEventData->mState)
{
- CharacterIndex handlePosition = 0u;
- if( handleStopScrolling )
+ if(mModel->mLogicalModel->mText.Count() && !IsShowingPlaceholderText())
{
- // The event.p2 and event.p3 are in decorator coords. Need to transforms to text coords.
- const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x;
- const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y;
-
- handlePosition = Text::GetClosestCursorIndex( mVisualModel,
- mLogicalModel,
- mMetrics,
- xPosition,
- yPosition );
+ buttonsToShow = TextSelectionPopup::Buttons(TextSelectionPopup::SELECT | TextSelectionPopup::SELECT_ALL);
}
- if( Event::GRAB_HANDLE_EVENT == event.type )
+ if(!IsClipboardEmpty())
{
- mEventData->mUpdateCursorPosition = true;
- mEventData->mUpdateInputStyle = true;
-
- if( !IsClipboardEmpty() )
+ if(isEditable)
{
- ChangeState( EventData::EDITING_WITH_PASTE_POPUP ); // Moving grabhandle will show Paste Popup
- }
-
- if( handleStopScrolling )
- {
- mEventData->mScrollAfterUpdatePosition = mEventData->mPrimaryCursorPosition != handlePosition;
- mEventData->mPrimaryCursorPosition = handlePosition;
+ buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::PASTE));
}
+ buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::CLIPBOARD));
}
- else if( Event::LEFT_SELECTION_HANDLE_EVENT == event.type )
+ }
+ else if(EventData::EDITING_WITH_PASTE_POPUP == mEventData->mState)
+ {
+ if(!IsClipboardEmpty())
{
- ChangeState( EventData::SELECTING );
-
- if( handleStopScrolling )
+ if(isEditable)
{
- mEventData->mUpdateLeftSelectionPosition = ( mEventData->mRightSelectionPosition != handlePosition );
- mEventData->mScrollAfterUpdatePosition = mEventData->mUpdateLeftSelectionPosition;
-
- if( mEventData->mUpdateLeftSelectionPosition )
- {
- mEventData->mLeftSelectionPosition = handlePosition;
- }
+ buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::PASTE));
}
+ buttonsToShow = TextSelectionPopup::Buttons((buttonsToShow | TextSelectionPopup::CLIPBOARD));
}
- else if( Event::RIGHT_SELECTION_HANDLE_EVENT == event.type )
- {
- ChangeState( EventData::SELECTING );
+ }
- if( handleStopScrolling )
- {
- mEventData->mUpdateRightSelectionPosition = ( mEventData->mLeftSelectionPosition != handlePosition );
- mEventData->mScrollAfterUpdatePosition = mEventData->mUpdateRightSelectionPosition;
- if( mEventData->mUpdateRightSelectionPosition )
- {
- mEventData->mRightSelectionPosition = handlePosition;
- }
- }
- }
+ mEventData->mDecorator->SetEnabledPopupButtons(buttonsToShow);
+}
- mEventData->mDecoratorUpdated = true;
- } // end ( ( HANDLE_RELEASED == state ) || ( HANDLE_STOP_SCROLLING == state ) )
- else if( HANDLE_SCROLLING == state )
+void Controller::Impl::ChangeState(EventData::State newState)
+{
+ ChangeTextControllerState(*this, newState);
+}
+
+void Controller::Impl::GetCursorPosition(CharacterIndex logical,
+ CursorInfo& cursorInfo)
+{
+ if(!IsShowingRealText())
{
- const float xSpeed = event.p2.mFloat;
- const Vector2& actualSize = mVisualModel->GetLayoutSize();
- const Vector2 currentScrollPosition = mEventData->mScrollPosition;
+ // Do not want to use the place-holder text to set the cursor position.
- mEventData->mScrollPosition.x += xSpeed;
+ // Use the line's height of the font's family set to set the cursor's size.
+ // If there is no font's family set, use the default font.
+ // Use the current alignment to place the cursor at the beginning, center or end of the box.
- ClampHorizontalScroll( actualSize );
+ cursorInfo.lineOffset = 0.f;
+ cursorInfo.lineHeight = GetDefaultFontLineHeight();
+ cursorInfo.primaryCursorHeight = cursorInfo.lineHeight;
- bool endOfScroll = false;
- if( Vector2::ZERO == ( currentScrollPosition - mEventData->mScrollPosition ) )
+ bool isRTL = false;
+ if(mModel->mMatchLayoutDirection != DevelText::MatchLayoutDirection::CONTENTS)
{
- // Notify the decorator there is no more text to scroll.
- // The decorator won't send more scroll events.
- mEventData->mDecorator->NotifyEndOfScroll();
- // Still need to set the position of the handle.
- endOfScroll = true;
+ isRTL = mLayoutDirection == LayoutDirection::RIGHT_TO_LEFT;
}
- // Set the position of the handle.
- const bool scrollRightDirection = xSpeed > 0.f;
- const bool leftSelectionHandleEvent = Event::LEFT_SELECTION_HANDLE_EVENT == event.type;
- const bool rightSelectionHandleEvent = Event::RIGHT_SELECTION_HANDLE_EVENT == event.type;
-
- if( Event::GRAB_HANDLE_EVENT == event.type )
- {
- ChangeState( EventData::GRAB_HANDLE_PANNING );
-
- Vector2 position = mEventData->mDecorator->GetPosition( GRAB_HANDLE );
-
- // Position the grag handle close to either the left or right edge.
- position.x = scrollRightDirection ? 0.f : mVisualModel->mControlSize.width;
-
- // Get the new handle position.
- // The grab handle's position is in decorator coords. Need to transforms to text coords.
- const CharacterIndex handlePosition = Text::GetClosestCursorIndex( mVisualModel,
- mLogicalModel,
- mMetrics,
- position.x - mEventData->mScrollPosition.x - mAlignmentOffset.x,
- position.y - mEventData->mScrollPosition.y - mAlignmentOffset.y );
-
- mEventData->mUpdateCursorPosition = mEventData->mPrimaryCursorPosition != handlePosition;
- mEventData->mScrollAfterUpdatePosition = mEventData->mUpdateCursorPosition;
- mEventData->mPrimaryCursorPosition = handlePosition;
- mEventData->mUpdateInputStyle = mEventData->mUpdateCursorPosition;
- }
- else if( leftSelectionHandleEvent || rightSelectionHandleEvent )
+ switch(mModel->mHorizontalAlignment)
{
- // TODO: This is recalculating the selection box every time the text is scrolled with the selection handles.
- // Think if something can be done to save power.
-
- ChangeState( EventData::SELECTION_HANDLE_PANNING );
-
- Vector2 position = mEventData->mDecorator->GetPosition( leftSelectionHandleEvent ? Text::LEFT_SELECTION_HANDLE : Text::RIGHT_SELECTION_HANDLE );
-
- // Position the selection handle close to either the left or right edge.
- position.x = scrollRightDirection ? 0.f : mVisualModel->mControlSize.width;
-
- // Get the new handle position.
- // The selection handle's position is in decorator coords. Need to transforms to text coords.
- const CharacterIndex handlePosition = Text::GetClosestCursorIndex( mVisualModel,
- mLogicalModel,
- mMetrics,
- position.x - mEventData->mScrollPosition.x - mAlignmentOffset.x,
- position.y - mEventData->mScrollPosition.y - mAlignmentOffset.y );
-
- if( leftSelectionHandleEvent )
+ case Text::HorizontalAlignment::BEGIN:
{
- const bool differentHandles = ( mEventData->mLeftSelectionPosition != handlePosition ) && ( mEventData->mRightSelectionPosition != handlePosition );
- mEventData->mUpdateLeftSelectionPosition = endOfScroll || differentHandles;
- if( differentHandles )
+ if(isRTL)
{
- mEventData->mLeftSelectionPosition = handlePosition;
+ cursorInfo.primaryPosition.x = mModel->mVisualModel->mControlSize.width - mEventData->mDecorator->GetCursorWidth();
}
- }
- else
- {
- const bool differentHandles = ( mEventData->mRightSelectionPosition != handlePosition ) && ( mEventData->mLeftSelectionPosition != handlePosition );
- mEventData->mUpdateRightSelectionPosition = endOfScroll || differentHandles;
- if( differentHandles )
+ else
{
- mEventData->mRightSelectionPosition = handlePosition;
+ cursorInfo.primaryPosition.x = 0.f;
}
+ break;
}
-
- if( mEventData->mUpdateLeftSelectionPosition || mEventData->mUpdateRightSelectionPosition )
+ case Text::HorizontalAlignment::CENTER:
{
- RepositionSelectionHandles();
-
- mEventData->mScrollAfterUpdatePosition = true;
+ cursorInfo.primaryPosition.x = floorf(0.5f * mModel->mVisualModel->mControlSize.width);
+ break;
+ }
+ case Text::HorizontalAlignment::END:
+ {
+ if(isRTL)
+ {
+ cursorInfo.primaryPosition.x = 0.f;
+ }
+ else
+ {
+ cursorInfo.primaryPosition.x = mModel->mVisualModel->mControlSize.width - mEventData->mDecorator->GetCursorWidth();
+ }
+ break;
}
}
- mEventData->mDecoratorUpdated = true;
- } // end ( HANDLE_SCROLLING == state )
-}
-void Controller::Impl::OnSelectEvent( const Event& event )
-{
- if( NULL == mEventData )
- {
- // Nothing to do if there is no text.
+ // Nothing else to do.
return;
}
- if( mEventData->mSelectionEnabled )
+ const bool isMultiLine = (Layout::Engine::MULTI_LINE_BOX == mLayoutEngine.GetLayout());
+ GetCursorPositionParameters parameters;
+ parameters.visualModel = mModel->mVisualModel;
+ parameters.logicalModel = mModel->mLogicalModel;
+ parameters.metrics = mMetrics;
+ parameters.logical = logical;
+ parameters.isMultiline = isMultiLine;
+
+ float defaultFontLineHeight = GetDefaultFontLineHeight();
+
+ Text::GetCursorPosition(parameters,
+ defaultFontLineHeight,
+ cursorInfo);
+
+ // Adds Outline offset.
+ const float outlineWidth = static_cast<float>(mModel->GetOutlineWidth());
+ cursorInfo.primaryPosition.x += outlineWidth;
+ cursorInfo.primaryPosition.y += outlineWidth;
+ cursorInfo.secondaryPosition.x += outlineWidth;
+ cursorInfo.secondaryPosition.y += outlineWidth;
+
+ if(isMultiLine)
{
- // The event.p2 and event.p3 are in decorator coords. Need to transforms to text coords.
- const float xPosition = event.p2.mFloat - mEventData->mScrollPosition.x - mAlignmentOffset.x;
- const float yPosition = event.p3.mFloat - mEventData->mScrollPosition.y - mAlignmentOffset.y;
+ // If the text is editable and multi-line, the cursor position after a white space shouldn't exceed the boundaries of the text control.
- // Calculates the logical position from the x,y coords.
- RepositionSelectionHandles( xPosition,
- yPosition );
+ // Note the white spaces laid-out at the end of the line might exceed the boundaries of the control.
+ // The reason is a wrapped line must not start with a white space so they are laid-out at the end of the line.
- mEventData->mUpdateLeftSelectionPosition = true;
- mEventData->mUpdateRightSelectionPosition = true;
- mEventData->mUpdateCursorPosition = false;
+ if(0.f > cursorInfo.primaryPosition.x)
+ {
+ cursorInfo.primaryPosition.x = 0.f;
+ }
- mEventData->mScrollAfterUpdatePosition = ( mEventData->mLeftSelectionPosition != mEventData->mRightSelectionPosition );
+ const float edgeWidth = mModel->mVisualModel->mControlSize.width - static_cast<float>(mEventData->mDecorator->GetCursorWidth());
+ if(cursorInfo.primaryPosition.x > edgeWidth)
+ {
+ cursorInfo.primaryPosition.x = edgeWidth;
+ }
}
}
-void Controller::Impl::OnSelectAllEvent()
+CharacterIndex Controller::Impl::CalculateNewCursorIndex(CharacterIndex index) const
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "OnSelectAllEvent mEventData->mSelectionEnabled%s \n", mEventData->mSelectionEnabled?"true":"false");
-
- if( NULL == mEventData )
+ if(nullptr == mEventData)
{
- // Nothing to do if there is no text.
- return;
+ // Nothing to do if there is no text input.
+ return 0u;
}
- if( mEventData->mSelectionEnabled )
+ CharacterIndex cursorIndex = mEventData->mPrimaryCursorPosition;
+
+ const GlyphIndex* const charactersToGlyphBuffer = mModel->mVisualModel->mCharactersToGlyph.Begin();
+ const Length* const charactersPerGlyphBuffer = mModel->mVisualModel->mCharactersPerGlyph.Begin();
+
+ GlyphIndex glyphIndex = *(charactersToGlyphBuffer + index);
+ Length numberOfCharacters = *(charactersPerGlyphBuffer + glyphIndex);
+
+ if(numberOfCharacters > 1u)
{
- mEventData->mLeftSelectionPosition = 0u;
- mEventData->mRightSelectionPosition = mLogicalModel->mText.Count();
+ const Script script = mModel->mLogicalModel->GetScript(index);
+ if(HasLigatureMustBreak(script))
+ {
+ // Prevents to jump the whole Latin ligatures like fi, ff, or Arabic ﻻ, ...
+ numberOfCharacters = 1u;
+ }
+ }
+ else
+ {
+ while(0u == numberOfCharacters)
+ {
+ ++glyphIndex;
+ numberOfCharacters = *(charactersPerGlyphBuffer + glyphIndex);
+ }
+ }
- mEventData->mScrollAfterUpdatePosition = true;
- mEventData->mUpdateLeftSelectionPosition = true;
- mEventData->mUpdateRightSelectionPosition = true;
+ if(index < mEventData->mPrimaryCursorPosition)
+ {
+ cursorIndex -= numberOfCharacters;
+ }
+ else
+ {
+ cursorIndex += numberOfCharacters;
}
+
+ // Will update the cursor hook position.
+ mEventData->mUpdateCursorHookPosition = true;
+
+ return cursorIndex;
}
-void Controller::Impl::RetrieveSelection( std::string& selectedText, bool deleteAfterRetrieval )
+void Controller::Impl::UpdateCursorPosition(const CursorInfo& cursorInfo)
{
- if( mEventData->mLeftSelectionPosition == mEventData->mRightSelectionPosition )
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "-->Controller::UpdateCursorPosition %p\n", this);
+ if(nullptr == mEventData)
{
- // Nothing to select if handles are in the same place.
- selectedText.clear();
+ // Nothing to do if there is no text input.
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::UpdateCursorPosition no event data\n");
return;
}
- const bool handlesCrossed = mEventData->mLeftSelectionPosition > mEventData->mRightSelectionPosition;
+ const Vector2 cursorPosition = cursorInfo.primaryPosition + mModel->mScrollPosition;
- //Get start and end position of selection
- const CharacterIndex startOfSelectedText = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
- const Length lengthOfSelectedText = ( handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition ) - startOfSelectedText;
+ mEventData->mDecorator->SetGlyphOffset(PRIMARY_CURSOR, cursorInfo.glyphOffset);
- Vector<Character>& utf32Characters = mLogicalModel->mText;
- const Length numberOfCharacters = utf32Characters.Count();
+ // Sets the cursor position.
+ mEventData->mDecorator->SetPosition(PRIMARY_CURSOR,
+ cursorPosition.x,
+ cursorPosition.y,
+ cursorInfo.primaryCursorHeight,
+ cursorInfo.lineHeight);
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Primary cursor position: %f,%f\n", cursorPosition.x, cursorPosition.y);
- // Validate the start and end selection points
- if( ( startOfSelectedText + lengthOfSelectedText ) <= numberOfCharacters )
+ if(mEventData->mUpdateGrabHandlePosition)
{
- //Get text as a UTF8 string
- Utf32ToUtf8( &utf32Characters[startOfSelectedText], lengthOfSelectedText, selectedText );
-
- if( deleteAfterRetrieval ) // Only delete text if copied successfully
- {
- // Set as input style the style of the first deleted character.
- mLogicalModel->RetrieveStyle( startOfSelectedText, mEventData->mInputStyle );
-
- mLogicalModel->UpdateTextStyleRuns( startOfSelectedText, -static_cast<int>( lengthOfSelectedText ) );
-
- // Mark the paragraphs to be updated.
- mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
- mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
-
- // Delete text between handles
- Vector<Character>::Iterator first = utf32Characters.Begin() + startOfSelectedText;
- Vector<Character>::Iterator last = first + lengthOfSelectedText;
- utf32Characters.Erase( first, last );
-
- // Scroll after delete.
- mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
- }
- mEventData->mDecoratorUpdated = true;
+ // Sets the grab handle position.
+ mEventData->mDecorator->SetPosition(GRAB_HANDLE,
+ cursorPosition.x,
+ cursorInfo.lineOffset + mModel->mScrollPosition.y,
+ cursorInfo.lineHeight);
}
-}
-void Controller::Impl::ShowClipboard()
-{
- if( mClipboard )
+ if(cursorInfo.isSecondaryCursor)
{
- mClipboard.ShowClipboard();
+ mEventData->mDecorator->SetPosition(SECONDARY_CURSOR,
+ cursorInfo.secondaryPosition.x + mModel->mScrollPosition.x,
+ cursorInfo.secondaryPosition.y + mModel->mScrollPosition.y,
+ cursorInfo.secondaryCursorHeight,
+ cursorInfo.lineHeight);
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "Secondary cursor position: %f,%f\n", cursorInfo.secondaryPosition.x + mModel->mScrollPosition.x, cursorInfo.secondaryPosition.y + mModel->mScrollPosition.y);
}
-}
-void Controller::Impl::HideClipboard()
-{
- if( mClipboard && mClipboardHideEnabled )
+ // Set which cursors are active according the state.
+ if(EventData::IsEditingState(mEventData->mState) || (EventData::GRAB_HANDLE_PANNING == mEventData->mState))
{
- mClipboard.HideClipboard();
+ if(cursorInfo.isSecondaryCursor)
+ {
+ mEventData->mDecorator->SetActiveCursor(ACTIVE_CURSOR_BOTH);
+ }
+ else
+ {
+ mEventData->mDecorator->SetActiveCursor(ACTIVE_CURSOR_PRIMARY);
+ }
+ }
+ else
+ {
+ mEventData->mDecorator->SetActiveCursor(ACTIVE_CURSOR_NONE);
}
-}
-void Controller::Impl::SetClipboardHideEnable(bool enable)
-{
- mClipboardHideEnabled = enable;
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "<--Controller::UpdateCursorPosition\n");
}
-bool Controller::Impl::CopyStringToClipboard( std::string& source )
+void Controller::Impl::UpdateSelectionHandle(HandleType handleType,
+ const CursorInfo& cursorInfo)
{
- //Send string to clipboard
- return ( mClipboard && mClipboard.SetItem( source ) );
+ SelectionHandleController::Update(*this, handleType, cursorInfo);
}
-void Controller::Impl::SendSelectionToClipboard( bool deleteAfterSending )
+void Controller::Impl::ClampHorizontalScroll(const Vector2& layoutSize)
{
- std::string selectedText;
- RetrieveSelection( selectedText, deleteAfterSending );
- CopyStringToClipboard( selectedText );
- ChangeState( EventData::EDITING );
-}
+ // Clamp between -space & -alignment offset.
-void Controller::Impl::GetTextFromClipboard( unsigned int itemIndex, std::string& retrievedString )
-{
- if ( mClipboard )
+ if(layoutSize.width > mModel->mVisualModel->mControlSize.width)
+ {
+ const float space = (layoutSize.width - mModel->mVisualModel->mControlSize.width) + mModel->mAlignmentOffset;
+ mModel->mScrollPosition.x = (mModel->mScrollPosition.x < -space) ? -space : mModel->mScrollPosition.x;
+ mModel->mScrollPosition.x = (mModel->mScrollPosition.x > -mModel->mAlignmentOffset) ? -mModel->mAlignmentOffset : mModel->mScrollPosition.x;
+
+ mEventData->mDecoratorUpdated = true;
+ }
+ else
{
- retrievedString = mClipboard.GetItem( itemIndex );
+ mModel->mScrollPosition.x = 0.f;
}
}
-void Controller::Impl::RepositionSelectionHandles()
+void Controller::Impl::ClampVerticalScroll(const Vector2& layoutSize)
{
- CharacterIndex selectionStart = mEventData->mLeftSelectionPosition;
- CharacterIndex selectionEnd = mEventData->mRightSelectionPosition;
-
- if( selectionStart == selectionEnd )
+ if(Layout::Engine::SINGLE_LINE_BOX == mLayoutEngine.GetLayout())
{
- // Nothing to select if handles are in the same place.
+ // Nothing to do if the text is single line.
return;
}
- mEventData->mDecorator->ClearHighlights();
-
- const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin();
- const Length* const glyphsPerCharacterBuffer = mVisualModel->mGlyphsPerCharacter.Begin();
- const GlyphInfo* const glyphsBuffer = mVisualModel->mGlyphs.Begin();
- const Vector2* const positionsBuffer = mVisualModel->mGlyphPositions.Begin();
- const Length* const charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin();
- const CharacterIndex* const glyphToCharacterBuffer = mVisualModel->mGlyphsToCharacters.Begin();
- const CharacterDirection* const modelCharacterDirectionsBuffer = ( 0u != mLogicalModel->mCharacterDirections.Count() ) ? mLogicalModel->mCharacterDirections.Begin() : NULL;
-
- // TODO: Better algorithm to create the highlight box.
- // TODO: Multi-line.
-
- // Get the height of the line.
- const Vector<LineRun>& lines = mVisualModel->mLines;
- const LineRun& firstLine = *lines.Begin();
- const float height = firstLine.ascender + -firstLine.descender;
-
- const bool isLastCharacter = selectionEnd >= mLogicalModel->mText.Count();
- const bool startDirection = ( ( NULL == modelCharacterDirectionsBuffer ) ? false : *( modelCharacterDirectionsBuffer + selectionStart ) );
- const bool endDirection = ( ( NULL == modelCharacterDirectionsBuffer ) ? false : *( modelCharacterDirectionsBuffer + ( selectionEnd - ( isLastCharacter ? 1u : 0u ) ) ) );
-
- // Swap the indices if the start is greater than the end.
- const bool indicesSwapped = selectionStart > selectionEnd;
-
- // Tell the decorator to flip the selection handles if needed.
- mEventData->mDecorator->SetSelectionHandleFlipState( indicesSwapped, startDirection, endDirection );
+ // Clamp between -space & 0.
+ if(layoutSize.height > mModel->mVisualModel->mControlSize.height)
+ {
+ const float space = (layoutSize.height - mModel->mVisualModel->mControlSize.height);
+ mModel->mScrollPosition.y = (mModel->mScrollPosition.y < -space) ? -space : mModel->mScrollPosition.y;
+ mModel->mScrollPosition.y = (mModel->mScrollPosition.y > 0.f) ? 0.f : mModel->mScrollPosition.y;
- if( indicesSwapped )
+ mEventData->mDecoratorUpdated = true;
+ }
+ else
{
- std::swap( selectionStart, selectionEnd );
+ mModel->mScrollPosition.y = 0.f;
}
+}
- // Get the indices to the first and last selected glyphs.
- const CharacterIndex selectionEndMinusOne = selectionEnd - 1u;
- const GlyphIndex glyphStart = *( charactersToGlyphBuffer + selectionStart );
- const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + selectionEndMinusOne );
- const GlyphIndex glyphEnd = *( charactersToGlyphBuffer + selectionEndMinusOne ) + ( ( numberOfGlyphs > 0 ) ? numberOfGlyphs - 1u : 0u );
+void Controller::Impl::ScrollToMakePositionVisible(const Vector2& position, float lineHeight)
+{
+ const float cursorWidth = mEventData->mDecorator ? static_cast<float>(mEventData->mDecorator->GetCursorWidth()) : 0.f;
- // Check if the first glyph is a ligature that must be broken like Latin ff, fi, or Arabic ﻻ, etc which needs special code.
- const Length numberOfCharactersStart = *( charactersPerGlyphBuffer + glyphStart );
- bool splitStartGlyph = ( numberOfCharactersStart > 1u ) && HasLigatureMustBreak( mLogicalModel->GetScript( selectionStart ) );
+ // position is in actor's coords.
+ const float positionEndX = position.x + cursorWidth;
+ const float positionEndY = position.y + lineHeight;
- // Check if the last glyph is a ligature that must be broken like Latin ff, fi, or Arabic ﻻ, etc which needs special code.
- const Length numberOfCharactersEnd = *( charactersPerGlyphBuffer + glyphEnd );
- bool splitEndGlyph = ( glyphStart != glyphEnd ) && ( numberOfCharactersEnd > 1u ) && HasLigatureMustBreak( mLogicalModel->GetScript( selectionEndMinusOne ) );
+ // Transform the position to decorator coords.
+ const float decoratorPositionBeginX = position.x + mModel->mScrollPosition.x;
+ const float decoratorPositionEndX = positionEndX + mModel->mScrollPosition.x;
- const Vector2 offset = mEventData->mScrollPosition + mAlignmentOffset;
+ const float decoratorPositionBeginY = position.y + mModel->mScrollPosition.y;
+ const float decoratorPositionEndY = positionEndY + mModel->mScrollPosition.y;
- // Traverse the glyphs.
- for( GlyphIndex index = glyphStart; index <= glyphEnd; ++index )
+ if(decoratorPositionBeginX < 0.f)
{
- const GlyphInfo& glyph = *( glyphsBuffer + index );
- const Vector2& position = *( positionsBuffer + index );
+ mModel->mScrollPosition.x = -position.x;
+ }
+ else if(decoratorPositionEndX > mModel->mVisualModel->mControlSize.width)
+ {
+ mModel->mScrollPosition.x = mModel->mVisualModel->mControlSize.width - positionEndX;
+ }
- if( splitStartGlyph )
+ if(Layout::Engine::MULTI_LINE_BOX == mLayoutEngine.GetLayout())
+ {
+ if(decoratorPositionBeginY < 0.f)
{
- // If the first glyph is a ligature that must be broken it may be needed to add only part of the glyph to the highlight box.
-
- const float glyphAdvance = glyph.advance / static_cast<float>( numberOfCharactersStart );
- const CharacterIndex interGlyphIndex = selectionStart - *( glyphToCharacterBuffer + glyphStart );
- // Get the direction of the character.
- CharacterDirection isCurrentRightToLeft = false;
- if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right.
- {
- isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + selectionStart );
- }
-
- // The end point could be in the middle of the ligature.
- // Calculate the number of characters selected.
- const Length numberOfCharacters = ( glyphStart == glyphEnd ) ? ( selectionEnd - selectionStart ) : ( numberOfCharactersStart - interGlyphIndex );
-
- const float xPosition = position.x - glyph.xBearing + offset.x + glyphAdvance * static_cast<float>( isCurrentRightToLeft ? ( numberOfCharactersStart - interGlyphIndex - numberOfCharacters ) : interGlyphIndex );
-
- mEventData->mDecorator->AddHighlight( xPosition,
- offset.y,
- xPosition + static_cast<float>( numberOfCharacters ) * glyphAdvance,
- offset.y + height );
-
- splitStartGlyph = false;
- continue;
+ mModel->mScrollPosition.y = -position.y;
}
-
- if( splitEndGlyph && ( index == glyphEnd ) )
+ else if(decoratorPositionEndY > mModel->mVisualModel->mControlSize.height)
{
- // Equally, if the last glyph is a ligature that must be broken it may be needed to add only part of the glyph to the highlight box.
-
- const float glyphAdvance = glyph.advance / static_cast<float>( numberOfCharactersEnd );
- const CharacterIndex interGlyphIndex = selectionEnd - *( glyphToCharacterBuffer + glyphEnd );
- // Get the direction of the character.
- CharacterDirection isCurrentRightToLeft = false;
- if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right.
- {
- isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + selectionEnd );
- }
-
- const Length numberOfCharacters = numberOfCharactersEnd - interGlyphIndex;
-
- const float xPosition = position.x - glyph.xBearing + offset.x + ( isCurrentRightToLeft ? ( glyphAdvance * static_cast<float>( numberOfCharacters ) ) : 0.f );
- mEventData->mDecorator->AddHighlight( xPosition,
- offset.y,
- xPosition + static_cast<float>( interGlyphIndex ) * glyphAdvance,
- offset.y + height );
-
- splitEndGlyph = false;
- continue;
+ mModel->mScrollPosition.y = mModel->mVisualModel->mControlSize.height - positionEndY;
+ }
+ else if(mModel->mLogicalModel->mText.Count() == 0u)
+ {
+ Relayouter::CalculateVerticalOffset(*this, mModel->mVisualModel->mControlSize);
}
-
- const float xPosition = position.x - glyph.xBearing + offset.x;
- mEventData->mDecorator->AddHighlight( xPosition,
- offset.y,
- xPosition + glyph.advance,
- offset.y + height );
}
+}
- CursorInfo primaryCursorInfo;
- GetCursorPosition( mEventData->mLeftSelectionPosition,
- primaryCursorInfo );
+void Controller::Impl::ScrollTextToMatchCursor(const CursorInfo& cursorInfo)
+{
+ // Get the current cursor position in decorator coords.
+ const Vector2& currentCursorPosition = mEventData->mDecorator->GetPosition(PRIMARY_CURSOR);
- CursorInfo secondaryCursorInfo;
- GetCursorPosition( mEventData->mRightSelectionPosition,
- secondaryCursorInfo );
+ const LineIndex lineIndex = mModel->mVisualModel->GetLineOfCharacter(mEventData->mPrimaryCursorPosition);
- const Vector2 primaryPosition = primaryCursorInfo.primaryPosition + offset;
- const Vector2 secondaryPosition = secondaryCursorInfo.primaryPosition + offset;
+ // Calculate the offset to match the cursor position before the character was deleted.
+ mModel->mScrollPosition.x = currentCursorPosition.x - cursorInfo.primaryPosition.x;
- mEventData->mDecorator->SetPosition( LEFT_SELECTION_HANDLE,
- primaryPosition.x,
- primaryCursorInfo.lineOffset + offset.y,
- primaryCursorInfo.lineHeight );
+ //If text control has more than two lines and current line index is not last, calculate scrollpositionY
+ if(mModel->mVisualModel->mLines.Count() > 1u && lineIndex != mModel->mVisualModel->mLines.Count() - 1u)
+ {
+ const float currentCursorGlyphOffset = mEventData->mDecorator->GetGlyphOffset(PRIMARY_CURSOR);
+ mModel->mScrollPosition.y = currentCursorPosition.y - cursorInfo.lineOffset - currentCursorGlyphOffset;
+ }
- mEventData->mDecorator->SetPosition( RIGHT_SELECTION_HANDLE,
- secondaryPosition.x,
- secondaryCursorInfo.lineOffset + offset.y,
- secondaryCursorInfo.lineHeight );
+ ClampHorizontalScroll(mModel->mVisualModel->GetLayoutSize());
+ ClampVerticalScroll(mModel->mVisualModel->GetLayoutSize());
- // Cursor to be positioned at end of selection so if selection interrupted and edit mode restarted the cursor will be at end of selection
- mEventData->mPrimaryCursorPosition = ( indicesSwapped ) ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition;
+ // Makes the new cursor position visible if needed.
+ ScrollToMakePositionVisible(cursorInfo.primaryPosition, cursorInfo.lineHeight);
+}
- // Set the flag to update the decorator.
- mEventData->mDecoratorUpdated = true;
+void Controller::Impl::ScrollTextToMatchCursor()
+{
+ CursorInfo cursorInfo;
+ GetCursorPosition(mEventData->mPrimaryCursorPosition, cursorInfo);
+ ScrollTextToMatchCursor(cursorInfo);
}
-void Controller::Impl::RepositionSelectionHandles( float visualX, float visualY )
+void Controller::Impl::RequestRelayout()
{
- if( NULL == mEventData )
+ if(nullptr != mControlInterface)
{
- // Nothing to do if there is no text input.
- return;
+ mControlInterface->RequestTextRelayout();
}
+}
- if( IsShowingPlaceholderText() )
- {
- // Nothing to do if there is the place-holder text.
- return;
- }
+void Controller::Impl::RelayoutAllCharacters()
+{
+ // relayout all characters
+ mTextUpdateInfo.mCharacterIndex = 0;
+ mTextUpdateInfo.mNumberOfCharactersToRemove = mTextUpdateInfo.mPreviousNumberOfCharacters;
+ mTextUpdateInfo.mNumberOfCharactersToAdd = mModel->mLogicalModel->mText.Count();
+ mOperationsPending = static_cast<OperationsMask>(mOperationsPending | LAYOUT);
- const Length numberOfGlyphs = mVisualModel->mGlyphs.Count();
- const Length numberOfLines = mVisualModel->mLines.Count();
- if( ( 0 == numberOfGlyphs ) ||
- ( 0 == numberOfLines ) )
- {
- // Nothing to do if there is no text.
- return;
- }
+ mTextUpdateInfo.mFullRelayoutNeeded = true;
- // Find which word was selected
- CharacterIndex selectionStart( 0 );
- CharacterIndex selectionEnd( 0 );
- FindSelectionIndices( mVisualModel,
- mLogicalModel,
- mMetrics,
- visualX,
- visualY,
- selectionStart,
- selectionEnd );
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "%p selectionStart %d selectionEnd %d\n", this, selectionStart, selectionEnd );
+ // Need to recalculate natural size
+ mRecalculateNaturalSize = true;
- if( selectionStart == selectionEnd )
+ //remove selection
+ if((mEventData != nullptr) && (mEventData->mState == EventData::SELECTING))
{
- ChangeState( EventData::EDITING );
- // Nothing to select. i.e. a white space, out of bounds
- return;
+ ChangeState(EventData::EDITING);
}
- mEventData->mLeftSelectionPosition = selectionStart;
- mEventData->mRightSelectionPosition = selectionEnd;
+ RequestRelayout();
}
-void Controller::Impl::SetPopupButtons()
+bool Controller::Impl::IsInputStyleChangedSignalsQueueEmpty()
{
- /**
- * Sets the Popup buttons to be shown depending on State.
- *
- * If SELECTING : CUT & COPY + ( PASTE & CLIPBOARD if content available to paste )
- *
- * If EDITING_WITH_POPUP : SELECT & SELECT_ALL
- */
-
- TextSelectionPopup::Buttons buttonsToShow = TextSelectionPopup::NONE;
+ return (NULL == mEventData) || (0u == mEventData->mInputStyleChangedQueue.Count());
+}
- if( EventData::SELECTING == mEventData->mState )
+void Controller::Impl::ProcessInputStyleChangedSignals()
+{
+ if(mEventData)
{
- buttonsToShow = TextSelectionPopup::Buttons( TextSelectionPopup::CUT | TextSelectionPopup::COPY );
-
- if( !IsClipboardEmpty() )
+ if(mEditableControlInterface)
{
- buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::PASTE ) );
- buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::CLIPBOARD ) );
+ // Emit the input style changed signal for each mask
+ std::for_each(mEventData->mInputStyleChangedQueue.begin(),
+ mEventData->mInputStyleChangedQueue.end(),
+ [&](const auto mask) { mEditableControlInterface->InputStyleChanged(mask); });
}
- if( !mEventData->mAllTextSelected )
- {
- buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::SELECT_ALL ) );
- }
+ mEventData->mInputStyleChangedQueue.Clear();
}
- else if( EventData::EDITING_WITH_POPUP == mEventData->mState )
+}
+
+void Controller::Impl::ScrollBy(Vector2 scroll)
+{
+ if(mEventData && (fabs(scroll.x) > Math::MACHINE_EPSILON_0 || fabs(scroll.y) > Math::MACHINE_EPSILON_0))
{
- if( mLogicalModel->mText.Count() && !IsShowingPlaceholderText() )
+ const Vector2& layoutSize = mModel->mVisualModel->GetLayoutSize();
+ const Vector2 currentScroll = mModel->mScrollPosition;
+
+ scroll.x = -scroll.x;
+ scroll.y = -scroll.y;
+
+ if(fabs(scroll.x) > Math::MACHINE_EPSILON_0)
{
- buttonsToShow = TextSelectionPopup::Buttons( TextSelectionPopup::SELECT | TextSelectionPopup::SELECT_ALL );
+ mModel->mScrollPosition.x += scroll.x;
+ ClampHorizontalScroll(layoutSize);
}
- if( !IsClipboardEmpty() )
+ if(fabs(scroll.y) > Math::MACHINE_EPSILON_0)
{
- buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::PASTE ) );
- buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::CLIPBOARD ) );
+ mModel->mScrollPosition.y += scroll.y;
+ ClampVerticalScroll(layoutSize);
}
- }
- else if( EventData::EDITING_WITH_PASTE_POPUP == mEventData->mState )
- {
- if ( !IsClipboardEmpty() )
+
+ if(mModel->mScrollPosition != currentScroll)
{
- buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::PASTE ) );
- buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::CLIPBOARD ) );
+ mEventData->mDecorator->UpdatePositions(mModel->mScrollPosition - currentScroll);
+ RequestRelayout();
}
}
-
- mEventData->mDecorator->SetEnabledPopupButtons( buttonsToShow );
}
-void Controller::Impl::ChangeState( EventData::State newState )
+bool Controller::Impl::IsScrollable(const Vector2& displacement)
{
- if( NULL == mEventData )
- {
- // Nothing to do if there is no text input.
- return;
- }
-
- DALI_LOG_INFO( gLogFilter, Debug::General, "ChangeState state:%d newstate:%d\n", mEventData->mState, newState );
-
- if( mEventData->mState != newState )
+ bool isScrollable = false;
+ if(mEventData)
{
- mEventData->mState = newState;
-
- if( EventData::INACTIVE == mEventData->mState )
- {
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
- mEventData->mDecorator->StopCursorBlink();
- mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
- mEventData->mDecorator->SetPopupActive( false );
- mEventData->mDecoratorUpdated = true;
- HideClipboard();
- }
- else if( EventData::INTERRUPTED == mEventData->mState)
- {
- mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
- mEventData->mDecorator->SetPopupActive( false );
- mEventData->mDecoratorUpdated = true;
- HideClipboard();
- }
- else if( EventData::SELECTING == mEventData->mState )
- {
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
- mEventData->mDecorator->StopCursorBlink();
- mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, true );
- mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, true );
- if( mEventData->mGrabHandlePopupEnabled )
- {
- SetPopupButtons();
- mEventData->mDecorator->SetPopupActive( true );
- }
- mEventData->mDecoratorUpdated = true;
- }
- else if( EventData::EDITING == mEventData->mState )
- {
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
- if( mEventData->mCursorBlinkEnabled )
- {
- mEventData->mDecorator->StartCursorBlink();
- }
- // Grab handle is not shown until a tap is received whilst EDITING
- mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
- if( mEventData->mGrabHandlePopupEnabled )
- {
- mEventData->mDecorator->SetPopupActive( false );
- }
- mEventData->mDecoratorUpdated = true;
- HideClipboard();
- }
- else if( EventData::EDITING_WITH_POPUP == mEventData->mState )
+ const bool isHorizontalScrollEnabled = mEventData->mDecorator->IsHorizontalScrollEnabled();
+ const bool isVerticalScrollEnabled = mEventData->mDecorator->IsVerticalScrollEnabled();
+ if(isHorizontalScrollEnabled ||isVerticalScrollEnabled)
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_POPUP \n", newState );
+ const Vector2& targetSize = mModel->mVisualModel->mControlSize;
+ const Vector2& layoutSize = mModel->mVisualModel->GetLayoutSize();
+ const Vector2& scrollPosition = mModel->mScrollPosition;
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
- if( mEventData->mCursorBlinkEnabled )
+ if(isHorizontalScrollEnabled)
{
- mEventData->mDecorator->StartCursorBlink();
- }
- if( mEventData->mSelectionEnabled )
- {
- mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
- }
- else
- {
- mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
- }
- if( mEventData->mGrabHandlePopupEnabled )
- {
- SetPopupButtons();
- mEventData->mDecorator->SetPopupActive( true );
+ const float displacementX = displacement.x;
+ const float positionX = scrollPosition.x + displacementX;
+ if(layoutSize.width > targetSize.width && -positionX > 0.f && -positionX < layoutSize.width - targetSize.width)
+ {
+ isScrollable = true;
+ }
}
- HideClipboard();
- mEventData->mDecoratorUpdated = true;
- }
- else if( EventData::EDITING_WITH_GRAB_HANDLE == mEventData->mState )
- {
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_GRAB_HANDLE \n", newState );
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
- if( mEventData->mCursorBlinkEnabled )
- {
- mEventData->mDecorator->StartCursorBlink();
- }
- // Grab handle is not shown until a tap is received whilst EDITING
- mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
- mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
- if( mEventData->mGrabHandlePopupEnabled )
- {
- mEventData->mDecorator->SetPopupActive( false );
- }
- mEventData->mDecoratorUpdated = true;
- HideClipboard();
- }
- else if( EventData::SELECTION_HANDLE_PANNING == mEventData->mState )
- {
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
- mEventData->mDecorator->StopCursorBlink();
- mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, true );
- mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, true );
- if( mEventData->mGrabHandlePopupEnabled )
+ if(isVerticalScrollEnabled)
{
- mEventData->mDecorator->SetPopupActive( false );
+ const float displacementY = displacement.y;
+ const float positionY = scrollPosition.y + displacementY;
+ if(layoutSize.height > targetSize.height && -positionY > 0 && -positionY < layoutSize.height - targetSize.height)
+ {
+ isScrollable = true;
+ }
}
- mEventData->mDecoratorUpdated = true;
}
- else if( EventData::GRAB_HANDLE_PANNING == mEventData->mState )
- {
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GRAB_HANDLE_PANNING \n", newState );
+ }
+ return isScrollable;
+}
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
- if( mEventData->mCursorBlinkEnabled )
- {
- mEventData->mDecorator->StartCursorBlink();
- }
- mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
- mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
- if( mEventData->mGrabHandlePopupEnabled )
- {
- mEventData->mDecorator->SetPopupActive( false );
- }
- mEventData->mDecoratorUpdated = true;
- }
- else if( EventData::EDITING_WITH_PASTE_POPUP == mEventData->mState )
- {
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_PASTE_POPUP \n", newState );
+float Controller::Impl::GetHorizontalScrollPosition()
+{
+ // Scroll values are negative internally so we convert them to positive numbers
+ return mEventData ? -mModel->mScrollPosition.x : 0.0f;
+}
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
- if( mEventData->mCursorBlinkEnabled )
- {
- mEventData->mDecorator->StartCursorBlink();
- }
+float Controller::Impl::GetVerticalScrollPosition()
+{
+ // Scroll values are negative internally so we convert them to positive numbers
+ return mEventData ? -mModel->mScrollPosition.y : 0.0f;
+}
- mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
- mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
- mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
+Vector3 Controller::Impl::GetAnchorPosition(Anchor anchor) const
+{
+ //TODO
+ return Vector3(10.f, 10.f, 10.f);
+}
- if( mEventData->mGrabHandlePopupEnabled )
- {
- SetPopupButtons();
- mEventData->mDecorator->SetPopupActive( true );
- }
- HideClipboard();
- mEventData->mDecoratorUpdated = true;
- }
- }
+Vector2 Controller::Impl::GetAnchorSize(Anchor anchor) const
+{
+ //TODO
+ return Vector2(10.f, 10.f);
+}
+
+Toolkit::TextAnchor Controller::Impl::CreateAnchorActor(Anchor anchor)
+{
+ auto actor = Toolkit::TextAnchor::New();
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ const Vector3 anchorPosition = GetAnchorPosition(anchor);
+ actor.SetProperty(Actor::Property::POSITION, anchorPosition);
+ const Vector2 anchorSize = GetAnchorSize(anchor);
+ actor.SetProperty(Actor::Property::SIZE, anchorSize);
+ std::string anchorText(mModel->mLogicalModel->mText.Begin() + anchor.startIndex, mModel->mLogicalModel->mText.Begin() + anchor.endIndex);
+ actor.SetProperty(Actor::Property::NAME, anchorText);
+ actor.SetProperty(Toolkit::TextAnchor::Property::URI, std::string(anchor.href));
+ actor.SetProperty(Toolkit::TextAnchor::Property::START_CHARACTER_INDEX, static_cast<int>(anchor.startIndex));
+ actor.SetProperty(Toolkit::TextAnchor::Property::END_CHARACTER_INDEX, static_cast<int>(anchor.endIndex));
+ return actor;
}
-void Controller::Impl::GetCursorPosition( CharacterIndex logical,
- CursorInfo& cursorInfo )
+void Controller::Impl::GetAnchorActors(std::vector<Toolkit::TextAnchor>& anchorActors)
{
- if( !IsShowingRealText() )
+ /* TODO: Now actors are created/destroyed in every "RenderText" function call. Even when we add just 1 character,
+ we need to create and destroy potentially many actors. Some optimization can be considered here.
+ Maybe a "dirty" flag in mLogicalModel? */
+ anchorActors.clear();
+ for(auto& anchor : mModel->mLogicalModel->mAnchors)
{
- // Do not want to use the place-holder text to set the cursor position.
+ auto actor = CreateAnchorActor(anchor);
+ anchorActors.push_back(actor);
+ }
+}
- // Use the line's height of the font's family set to set the cursor's size.
- // If there is no font's family set, use the default font.
- // Use the current alignment to place the cursor at the beginning, center or end of the box.
+int32_t Controller::Impl::GetAnchorIndex(size_t characterOffset) const
+{
+ Vector<Anchor>::Iterator it = mModel->mLogicalModel->mAnchors.Begin();
- cursorInfo.lineOffset = 0.f;
- cursorInfo.lineHeight = GetDefaultFontLineHeight();
- cursorInfo.primaryCursorHeight = cursorInfo.lineHeight;
+ while(it != mModel->mLogicalModel->mAnchors.End() && (it->startIndex > characterOffset || it->endIndex <= characterOffset))
+ {
+ it++;
+ }
- switch( mLayoutEngine.GetHorizontalAlignment() )
- {
- case LayoutEngine::HORIZONTAL_ALIGN_BEGIN:
- {
- cursorInfo.primaryPosition.x = 0.f;
- break;
- }
- case LayoutEngine::HORIZONTAL_ALIGN_CENTER:
- {
- cursorInfo.primaryPosition.x = floorf( 0.5f * mVisualModel->mControlSize.width );
- break;
- }
- case LayoutEngine::HORIZONTAL_ALIGN_END:
- {
- cursorInfo.primaryPosition.x = mVisualModel->mControlSize.width - mEventData->mDecorator->GetCursorWidth();
- break;
- }
- }
+ return it == mModel->mLogicalModel->mAnchors.End() ? -1 : it - mModel->mLogicalModel->mAnchors.Begin();
+}
- switch( mLayoutEngine.GetVerticalAlignment() )
- {
- case LayoutEngine::VERTICAL_ALIGN_TOP:
- {
- cursorInfo.primaryPosition.y = 0.f;
- break;
- }
- case LayoutEngine::VERTICAL_ALIGN_CENTER:
- {
- cursorInfo.primaryPosition.y = floorf( 0.5f * ( mVisualModel->mControlSize.height - cursorInfo.lineHeight ) );
- break;
- }
- case LayoutEngine::VERTICAL_ALIGN_BOTTOM:
- {
- cursorInfo.primaryPosition.y = mVisualModel->mControlSize.height - cursorInfo.lineHeight;
- break;
- }
- }
+void Controller::Impl::CopyUnderlinedFromLogicalToVisualModels(bool shouldClearPreUnderlineRuns)
+{
+ //Underlined character runs for markup-processor
+ const Vector<UnderlinedCharacterRun>& underlinedCharacterRuns = mModel->mLogicalModel->mUnderlinedCharacterRuns;
+ const Vector<GlyphIndex>& charactersToGlyph = mModel->mVisualModel->mCharactersToGlyph;
+ const Vector<Length>& glyphsPerCharacter = mModel->mVisualModel->mGlyphsPerCharacter;
- // Nothing else to do.
- return;
+ if(shouldClearPreUnderlineRuns)
+ {
+ mModel->mVisualModel->mUnderlineRuns.Clear();
}
- Text::GetCursorPosition( mVisualModel,
- mLogicalModel,
- mMetrics,
- logical,
- cursorInfo );
-
- if( LayoutEngine::MULTI_LINE_BOX == mLayoutEngine.GetLayout() )
+ for(Vector<UnderlinedCharacterRun>::ConstIterator it = underlinedCharacterRuns.Begin(), endIt = underlinedCharacterRuns.End(); it != endIt; ++it)
{
- // If the text is editable and multi-line, the cursor position after a white space shouldn't exceed the boundaries of the text control.
+ CharacterIndex characterIndex = it->characterRun.characterIndex;
+ Length numberOfCharacters = it->characterRun.numberOfCharacters;
- // Note the white spaces laid-out at the end of the line might exceed the boundaries of the control.
- // The reason is a wrapped line must not start with a white space so they are laid-out at the end of the line.
-
- if( 0.f > cursorInfo.primaryPosition.x )
+ if(numberOfCharacters == 0)
{
- cursorInfo.primaryPosition.x = 0.f;
+ continue;
}
- const float edgeWidth = mVisualModel->mControlSize.width - static_cast<float>( mEventData->mDecorator->GetCursorWidth() );
- if( cursorInfo.primaryPosition.x > edgeWidth )
+ // Create one run for all glyphs of all run's characters that has same properties
+ // This enhance performance and reduce the needed memory to store glyphs-runs
+ UnderlinedGlyphRun underlineGlyphRun;
+ underlineGlyphRun.glyphRun.glyphIndex = charactersToGlyph[characterIndex];
+ underlineGlyphRun.glyphRun.numberOfGlyphs = glyphsPerCharacter[characterIndex];
+ //Copy properties (attributes)
+ underlineGlyphRun.properties = it->properties;
+
+ for(Length index = 1u; index < numberOfCharacters; index++)
{
- cursorInfo.primaryPosition.x = edgeWidth;
+ underlineGlyphRun.glyphRun.numberOfGlyphs += glyphsPerCharacter[characterIndex + index];
}
+
+ mModel->mVisualModel->mUnderlineRuns.PushBack(underlineGlyphRun);
}
}
-CharacterIndex Controller::Impl::CalculateNewCursorIndex( CharacterIndex index ) const
+void Controller::Impl::CopyStrikethroughFromLogicalToVisualModels()
{
- if( NULL == mEventData )
- {
- // Nothing to do if there is no text input.
- return 0u;
- }
+ //Strikethrough character runs from markup-processor
+ const Vector<StrikethroughCharacterRun>& strikethroughCharacterRuns = mModel->mLogicalModel->mStrikethroughCharacterRuns;
+ const Vector<GlyphIndex>& charactersToGlyph = mModel->mVisualModel->mCharactersToGlyph;
+ const Vector<Length>& glyphsPerCharacter = mModel->mVisualModel->mGlyphsPerCharacter;
- CharacterIndex cursorIndex = mEventData->mPrimaryCursorPosition;
-
- const GlyphIndex* const charactersToGlyphBuffer = mVisualModel->mCharactersToGlyph.Begin();
- const Length* const charactersPerGlyphBuffer = mVisualModel->mCharactersPerGlyph.Begin();
+ mModel->mVisualModel->mStrikethroughRuns.Clear();
- GlyphIndex glyphIndex = *( charactersToGlyphBuffer + index );
- Length numberOfCharacters = *( charactersPerGlyphBuffer + glyphIndex );
-
- if( numberOfCharacters > 1u )
+ for(Vector<StrikethroughCharacterRun>::ConstIterator it = strikethroughCharacterRuns.Begin(), endIt = strikethroughCharacterRuns.End(); it != endIt; ++it)
{
- const Script script = mLogicalModel->GetScript( index );
- if( HasLigatureMustBreak( script ) )
+ CharacterIndex characterIndex = it->characterRun.characterIndex;
+ Length numberOfCharacters = it->characterRun.numberOfCharacters;
+
+ if(numberOfCharacters == 0)
{
- // Prevents to jump the whole Latin ligatures like fi, ff, or Arabic ﻻ, ...
- numberOfCharacters = 1u;
+ continue;
}
- }
- else
- {
- while( 0u == numberOfCharacters )
+
+ StrikethroughGlyphRun strikethroughGlyphRun;
+ strikethroughGlyphRun.properties = it->properties;
+ strikethroughGlyphRun.glyphRun.glyphIndex = charactersToGlyph[characterIndex];
+ strikethroughGlyphRun.glyphRun.numberOfGlyphs = glyphsPerCharacter[characterIndex];
+
+ for(Length index = 1u; index < numberOfCharacters; index++)
{
- ++glyphIndex;
- numberOfCharacters = *( charactersPerGlyphBuffer + glyphIndex );
+ strikethroughGlyphRun.glyphRun.numberOfGlyphs += glyphsPerCharacter[characterIndex + index];
}
- }
- if( index < mEventData->mPrimaryCursorPosition )
- {
- cursorIndex -= numberOfCharacters;
- }
- else
- {
- cursorIndex += numberOfCharacters;
+ mModel->mVisualModel->mStrikethroughRuns.PushBack(strikethroughGlyphRun);
}
-
- return cursorIndex;
}
-void Controller::Impl::UpdateCursorPosition( const CursorInfo& cursorInfo )
+void Controller::Impl::CopyCharacterSpacingFromLogicalToVisualModels()
{
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::UpdateCursorPosition %p\n", this );
- if( NULL == mEventData )
+ //CharacterSpacing character runs from markup-processor
+ const Vector<CharacterSpacingCharacterRun>& characterSpacingCharacterRuns = mModel->mLogicalModel->mCharacterSpacingCharacterRuns;
+ const Vector<GlyphIndex>& charactersToGlyph = mModel->mVisualModel->mCharactersToGlyph;
+ const Vector<Length>& glyphsPerCharacter = mModel->mVisualModel->mGlyphsPerCharacter;
+
+ mModel->mVisualModel->mCharacterSpacingRuns.Clear();
+
+ for(Vector<CharacterSpacingCharacterRun>::ConstIterator it = characterSpacingCharacterRuns.Begin(), endIt = characterSpacingCharacterRuns.End(); it != endIt; ++it)
{
- // Nothing to do if there is no text input.
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::UpdateCursorPosition no event data\n" );
- return;
- }
+ const CharacterIndex& characterIndex = it->characterRun.characterIndex;
+ const Length& numberOfCharacters = it->characterRun.numberOfCharacters;
- const Vector2 offset = mEventData->mScrollPosition + ( IsShowingRealText() ? mAlignmentOffset : Vector2::ZERO );
- const Vector2 cursorPosition = cursorInfo.primaryPosition + offset;
+ if(numberOfCharacters == 0)
+ {
+ continue;
+ }
- // Sets the cursor position.
- mEventData->mDecorator->SetPosition( PRIMARY_CURSOR,
- cursorPosition.x,
- cursorPosition.y,
- cursorInfo.primaryCursorHeight,
- cursorInfo.lineHeight );
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Primary cursor position: %f,%f\n", cursorPosition.x, cursorPosition.y );
+ CharacterSpacingGlyphRun characterSpacingGlyphRun;
+ characterSpacingGlyphRun.value = it->value;
+ characterSpacingGlyphRun.glyphRun.glyphIndex = charactersToGlyph[characterIndex];
+ characterSpacingGlyphRun.glyphRun.numberOfGlyphs = glyphsPerCharacter[characterIndex];
- // Sets the grab handle position.
- mEventData->mDecorator->SetPosition( GRAB_HANDLE,
- cursorPosition.x,
- cursorInfo.lineOffset + offset.y,
- cursorInfo.lineHeight );
+ for(Length index = 1u; index < numberOfCharacters; index++)
+ {
+ characterSpacingGlyphRun.glyphRun.numberOfGlyphs += glyphsPerCharacter[characterIndex + index];
+ }
- if( cursorInfo.isSecondaryCursor )
- {
- mEventData->mDecorator->SetPosition( SECONDARY_CURSOR,
- cursorInfo.secondaryPosition.x + offset.x,
- cursorInfo.secondaryPosition.y + offset.y,
- cursorInfo.secondaryCursorHeight,
- cursorInfo.lineHeight );
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Secondary cursor position: %f,%f\n", cursorInfo.secondaryPosition.x + offset.x, cursorInfo.secondaryPosition.y + offset.y );
+ mModel->mVisualModel->mCharacterSpacingRuns.PushBack(characterSpacingGlyphRun);
}
+}
- // Set which cursors are active according the state.
- if( EventData::IsEditingState( mEventData->mState ) || ( EventData::GRAB_HANDLE_PANNING == mEventData->mState ) )
+void Controller::Impl::SetAutoScrollEnabled(bool enable)
+{
+ if(mLayoutEngine.GetLayout() == Layout::Engine::SINGLE_LINE_BOX)
{
- if( cursorInfo.isSecondaryCursor )
+ mOperationsPending = static_cast<OperationsMask>(mOperationsPending |
+ LAYOUT |
+ ALIGN |
+ UPDATE_LAYOUT_SIZE |
+ REORDER);
+
+ if(enable)
{
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_BOTH );
+ DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled for SINGLE_LINE_BOX\n");
+ mOperationsPending = static_cast<OperationsMask>(mOperationsPending | UPDATE_DIRECTION);
}
else
{
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
+ DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled Disabling autoscroll\n");
}
+
+ mIsAutoScrollEnabled = enable;
+ RequestRelayout();
}
else
{
- mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
+ DALI_LOG_WARNING("Attempted AutoScrolling on a non SINGLE_LINE_BOX, request ignored\n");
+ mIsAutoScrollEnabled = false;
}
-
- DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::UpdateCursorPosition\n" );
}
-void Controller::Impl::UpdateSelectionHandle( HandleType handleType,
- const CursorInfo& cursorInfo )
+void Controller::Impl::SetEnableCursorBlink(bool enable)
{
- if( ( LEFT_SELECTION_HANDLE != handleType ) &&
- ( RIGHT_SELECTION_HANDLE != handleType ) )
- {
- return;
- }
+ DALI_ASSERT_DEBUG(NULL != mEventData && "TextInput disabled");
- const Vector2 offset = mEventData->mScrollPosition + mAlignmentOffset;
- const Vector2 cursorPosition = cursorInfo.primaryPosition + offset;
-
- // Sets the handle's position.
- mEventData->mDecorator->SetPosition( handleType,
- cursorPosition.x,
- cursorInfo.lineOffset + offset.y,
- cursorInfo.lineHeight );
+ if(mEventData)
+ {
+ mEventData->mCursorBlinkEnabled = enable;
- // If selection handle at start of the text and other at end of the text then all text is selected.
- const CharacterIndex startOfSelection = std::min( mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition );
- const CharacterIndex endOfSelection = std::max ( mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition );
- mEventData->mAllTextSelected = ( startOfSelection == 0 ) && ( endOfSelection == mLogicalModel->mText.Count() );
+ if(!enable && mEventData->mDecorator)
+ {
+ mEventData->mDecorator->StopCursorBlink();
+ }
+ }
}
-void Controller::Impl::ClampHorizontalScroll( const Vector2& actualSize )
+void Controller::Impl::SetMultiLineEnabled(bool enable)
{
- // Clamp between -space & 0 (and the text alignment).
+ const Layout::Engine::Type layout = enable ? Layout::Engine::MULTI_LINE_BOX : Layout::Engine::SINGLE_LINE_BOX;
- if( actualSize.width > mVisualModel->mControlSize.width )
+ if(layout != mLayoutEngine.GetLayout())
{
- const float space = ( actualSize.width - mVisualModel->mControlSize.width ) + mAlignmentOffset.x;
- mEventData->mScrollPosition.x = ( mEventData->mScrollPosition.x < -space ) ? -space : mEventData->mScrollPosition.x;
- mEventData->mScrollPosition.x = ( mEventData->mScrollPosition.x > -mAlignmentOffset.x ) ? -mAlignmentOffset.x : mEventData->mScrollPosition.x;
+ // Set the layout type.
+ mLayoutEngine.SetLayout(layout);
- mEventData->mDecoratorUpdated = true;
- }
- else
- {
- mEventData->mScrollPosition.x = 0.f;
+ // Set the flags to redo the layout operations
+ const OperationsMask layoutOperations = static_cast<OperationsMask>(LAYOUT |
+ UPDATE_LAYOUT_SIZE |
+ ALIGN |
+ REORDER);
+
+ mTextUpdateInfo.mFullRelayoutNeeded = true;
+ mOperationsPending = static_cast<OperationsMask>(mOperationsPending | layoutOperations);
+
+ // Need to recalculate natural size
+ mRecalculateNaturalSize = true;
+
+ RequestRelayout();
}
}
-void Controller::Impl::ClampVerticalScroll( const Vector2& actualSize )
+void Controller::Impl::SetHorizontalAlignment(Text::HorizontalAlignment::Type alignment)
{
- // Clamp between -space & 0 (and the text alignment).
- if( actualSize.height > mVisualModel->mControlSize.height )
+ if(alignment != mModel->mHorizontalAlignment)
{
- const float space = ( actualSize.height - mVisualModel->mControlSize.height ) + mAlignmentOffset.y;
- mEventData->mScrollPosition.y = ( mEventData->mScrollPosition.y < -space ) ? -space : mEventData->mScrollPosition.y;
- mEventData->mScrollPosition.y = ( mEventData->mScrollPosition.y > -mAlignmentOffset.y ) ? -mAlignmentOffset.y : mEventData->mScrollPosition.y;
-
- mEventData->mDecoratorUpdated = true;
+ // Set the alignment.
+ mModel->mHorizontalAlignment = alignment;
+ UpdateCursorPositionForAlignment(*this, true);
+ RequestRelayout();
}
- else
+}
+
+void Controller::Impl::SetVerticalAlignment(VerticalAlignment::Type alignment)
+{
+ if(alignment != mModel->mVerticalAlignment)
{
- mEventData->mScrollPosition.y = 0.f;
+ // Set the alignment.
+ mModel->mVerticalAlignment = alignment;
+ UpdateCursorPositionForAlignment(*this, false);
+ RequestRelayout();
}
}
-void Controller::Impl::ScrollToMakePositionVisible( const Vector2& position )
+void Controller::Impl::SetLineWrapMode(Text::LineWrap::Mode lineWrapMode)
{
- const float cursorWidth = mEventData->mDecorator ? mEventData->mDecorator->GetCursorWidth() : 0.f;
+ if(lineWrapMode != mModel->mLineWrapMode)
+ {
+ // Update Text layout for applying wrap mode
+ mOperationsPending = static_cast<OperationsMask>(mOperationsPending |
+ ALIGN |
+ LAYOUT |
+ UPDATE_LAYOUT_SIZE |
+ REORDER);
- // position is in actor's coords.
- const float positionEnd = position.x + cursorWidth;
+ if((mModel->mLineWrapMode == (Text::LineWrap::Mode)DevelText::LineWrap::HYPHENATION) || (lineWrapMode == (Text::LineWrap::Mode)DevelText::LineWrap::HYPHENATION) ||
+ (mModel->mLineWrapMode == (Text::LineWrap::Mode)DevelText::LineWrap::MIXED) || (lineWrapMode == (Text::LineWrap::Mode)DevelText::LineWrap::MIXED)) // hyphen is treated as line break
+ {
+ mOperationsPending = static_cast<OperationsMask>(mOperationsPending | GET_LINE_BREAKS);
+ }
- // Transform the position to decorator coords.
- const float alignment = IsShowingRealText() ? mAlignmentOffset.x : 0.f;
- const float offset = mEventData->mScrollPosition.x + alignment;
- const float decoratorPositionBegin = position.x + offset;
- const float decoratorPositionEnd = positionEnd + offset;
+ // Set the text wrap mode.
+ mModel->mLineWrapMode = lineWrapMode;
+
+ mTextUpdateInfo.mCharacterIndex = 0u;
+ mTextUpdateInfo.mNumberOfCharactersToRemove = mTextUpdateInfo.mPreviousNumberOfCharacters;
+ mTextUpdateInfo.mNumberOfCharactersToAdd = mModel->mLogicalModel->mText.Count();
+
+ // Request relayout
+ RequestRelayout();
+ }
+}
+
+void Controller::Impl::SetDefaultColor(const Vector4& color)
+{
+ mTextColor = color;
- if( decoratorPositionBegin < 0.f )
+ if(!IsShowingPlaceholderText())
{
- mEventData->mScrollPosition.x = -position.x - alignment;
+ mModel->mVisualModel->SetTextColor(color);
+ mModel->mLogicalModel->mColorRuns.Clear();
+ mOperationsPending = static_cast<OperationsMask>(mOperationsPending | COLOR);
+ RequestRelayout();
}
- else if( decoratorPositionEnd > mVisualModel->mControlSize.width )
+}
+
+void Controller::Impl::SetUserInteractionEnabled(bool enabled)
+{
+ mIsUserInteractionEnabled = enabled;
+
+ if(mEventData && mEventData->mDecorator)
{
- mEventData->mScrollPosition.x = mVisualModel->mControlSize.width - positionEnd - alignment;
+ bool editable = mEventData->mEditingEnabled && enabled;
+ mEventData->mDecorator->SetEditable(editable);
}
}
-void Controller::Impl::ScrollTextToMatchCursor( const CursorInfo& cursorInfo )
+void Controller::Impl::ClearFontData()
{
- // Get the current cursor position in decorator coords.
- const Vector2& currentCursorPosition = mEventData->mDecorator->GetPosition( PRIMARY_CURSOR );
+ if(mFontDefaults)
+ {
+ mFontDefaults->mFontId = 0u; // Remove old font ID
+ }
- // Calculate the offset to match the cursor position before the character was deleted.
- mEventData->mScrollPosition.x = currentCursorPosition.x - cursorInfo.primaryPosition.x - mAlignmentOffset.x;
+ // Set flags to update the model.
+ mTextUpdateInfo.mCharacterIndex = 0u;
+ mTextUpdateInfo.mNumberOfCharactersToRemove = mTextUpdateInfo.mPreviousNumberOfCharacters;
+ mTextUpdateInfo.mNumberOfCharactersToAdd = mModel->mLogicalModel->mText.Count();
- ClampHorizontalScroll( mVisualModel->GetLayoutSize() );
+ mTextUpdateInfo.mClearAll = true;
+ mTextUpdateInfo.mFullRelayoutNeeded = true;
+ mRecalculateNaturalSize = true;
- // Makes the new cursor position visible if needed.
- ScrollToMakePositionVisible( cursorInfo.primaryPosition );
+ mOperationsPending = static_cast<OperationsMask>(mOperationsPending |
+ VALIDATE_FONTS |
+ SHAPE_TEXT |
+ BIDI_INFO |
+ GET_GLYPH_METRICS |
+ LAYOUT |
+ UPDATE_LAYOUT_SIZE |
+ REORDER |
+ ALIGN);
}
-void Controller::Impl::RequestRelayout()
+void Controller::Impl::ClearStyleData()
{
- mControlInterface.RequestTextRelayout();
+ mModel->mLogicalModel->mColorRuns.Clear();
+ mModel->mLogicalModel->ClearFontDescriptionRuns();
+ mModel->mLogicalModel->ClearStrikethroughRuns();
}
-} // namespace Text
-
-} // namespace Toolkit
+void Controller::Impl::ResetScrollPosition()
+{
+ if(mEventData)
+ {
+ // Reset the scroll position.
+ mModel->mScrollPosition = Vector2::ZERO;
+ mEventData->mScrollAfterUpdatePosition = true;
+ }
+}
-} // namespace Dali
+} // namespace Dali::Toolkit::Text