X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Ftext-controls%2Ftext-label-impl.cpp;h=97ccc81eaecb1451f8a4eb5a58637aff8c453c76;hp=3ee507d434622d0d5c11a43d0018e2c7ae3aeb3b;hb=c427acac5f2616578c05987c99e7b430c9ab0137;hpb=c052b6678e2c6d8a65545dbbe4531ea7057c1999 diff --git a/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp b/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp index 3ee507d..97ccc81 100644 --- a/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp +++ b/dali-toolkit/internal/controls/text-controls/text-label-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,8 +19,8 @@ #include // EXTERNAL INCLUDES +#include #include -#include #include #include #include @@ -30,6 +30,7 @@ // INTERNAL INCLUDES #include #include +#include #include #include #include @@ -47,6 +48,7 @@ #include #include +// DEVEL INCLUDES #include using namespace Dali::Toolkit::Text; @@ -78,6 +80,7 @@ const std::string TEXT_FIT_ENABLE_KEY("enable"); const std::string TEXT_FIT_MIN_SIZE_KEY("minSize"); const std::string TEXT_FIT_MAX_SIZE_KEY("maxSize"); const std::string TEXT_FIT_STEP_SIZE_KEY("stepSize"); +const std::string TEXT_FIT_FONT_SIZE_KEY("fontSize"); const std::string TEXT_FIT_FONT_SIZE_TYPE_KEY("fontSizeType"); #if defined(DEBUG_ENABLED) @@ -133,12 +136,21 @@ DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "textFit", DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "minLineSize", FLOAT, MIN_LINE_SIZE ) DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "renderingBackend", INTEGER, RENDERING_BACKEND ) DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "fontSizeScale", FLOAT, FONT_SIZE_SCALE ) +DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "enableFontSizeScale", BOOLEAN, ENABLE_FONT_SIZE_SCALE ) +DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "ellipsisPosition", INTEGER, ELLIPSIS_POSITION ) +DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "strikethrough", MAP, STRIKETHROUGH ) +DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "characterSpacing", FLOAT, CHARACTER_SPACING ) +DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "relativeLineSize", FLOAT, RELATIVE_LINE_SIZE ) DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT(Toolkit, TextLabel, "textColor", Color::BLACK, TEXT_COLOR ) DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION(Toolkit, TextLabel, "textColorRed", TEXT_COLOR_RED, TEXT_COLOR, 0) DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION(Toolkit, TextLabel, "textColorGreen", TEXT_COLOR_GREEN, TEXT_COLOR, 1) DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION(Toolkit, TextLabel, "textColorBlue", TEXT_COLOR_BLUE, TEXT_COLOR, 2) DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION(Toolkit, TextLabel, "textColorAlpha", TEXT_COLOR_ALPHA, TEXT_COLOR, 3) + +DALI_SIGNAL_REGISTRATION(Toolkit, TextLabel, "anchorClicked", SIGNAL_ANCHOR_CLICKED) +DALI_SIGNAL_REGISTRATION(Toolkit, TextLabel, "textFitChanged", SIGNAL_TEXT_FIT_CHANGED) + DALI_TYPE_REGISTRATION_END() // clang-format on @@ -211,10 +223,10 @@ void ParseTextFitProperty(Text::ControllerPtr& controller, const Property::Map* } // namespace -Toolkit::TextLabel TextLabel::New() +Toolkit::TextLabel TextLabel::New(ControlBehaviour additionalBehaviour) { // Create the implementation, temporarily owned by this handle on stack - IntrusivePtr impl = new TextLabel(); + IntrusivePtr impl = new TextLabel(additionalBehaviour); // Pass ownership to CustomActor handle Toolkit::TextLabel handle(*impl); @@ -261,6 +273,17 @@ void TextLabel::SetProperty(BaseObject* object, Property::Index index, const Pro case Toolkit::TextLabel::Property::TEXT: { impl.mController->SetText(value.Get()); + + if(impl.mController->HasAnchors()) + { + // Forward input events to controller + impl.EnableGestureDetection(static_cast(GestureType::TAP)); + } + else + { + impl.DisableGestureDetection(static_cast(GestureType::TAP)); + } + break; } case Toolkit::TextLabel::Property::FONT_FAMILY: @@ -313,6 +336,16 @@ void TextLabel::SetProperty(BaseObject* object, Property::Index index, const Pro { const bool enableMarkup = value.Get(); impl.mController->SetMarkupProcessorEnabled(enableMarkup); + + if(impl.mController->HasAnchors()) + { + // Forward input events to controller + impl.EnableGestureDetection(static_cast(GestureType::TAP)); + } + else + { + impl.DisableGestureDetection(static_cast(GestureType::TAP)); + } break; } case Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL: @@ -453,12 +486,13 @@ void TextLabel::SetProperty(BaseObject* object, Property::Index index, const Pro } case Toolkit::DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION: { - impl.mController->SetMatchSystemLanguageDirection(value.Get()); + impl.mController->SetMatchLayoutDirection(value.Get() ? DevelText::MatchLayoutDirection::LOCALE : DevelText::MatchLayoutDirection::CONTENTS); break; } case Toolkit::DevelTextLabel::Property::TEXT_FIT: { ParseTextFitProperty(impl.mController, value.GetMap()); + impl.mController->SetTextFitChanged(true); break; } case Toolkit::DevelTextLabel::Property::MIN_LINE_SIZE: @@ -478,6 +512,44 @@ void TextLabel::SetProperty(BaseObject* object, Property::Index index, const Pro } break; } + case Toolkit::DevelTextLabel::Property::ENABLE_FONT_SIZE_SCALE: + { + const bool enableFontSizeScale = value.Get(); + if(!Equals(impl.mController->IsFontSizeScaleEnabled(), enableFontSizeScale)) + { + impl.mController->SetFontSizeScaleEnabled(enableFontSizeScale); + } + break; + } + case Toolkit::DevelTextLabel::Property::ELLIPSIS_POSITION: + { + DevelText::EllipsisPosition::Type ellipsisPositionType(static_cast(-1)); // Set to invalid value to ensure a valid mode does get set + if(GetEllipsisPositionTypeEnumeration(value, ellipsisPositionType)) + { + DALI_LOG_INFO(gLogFilter, Debug::General, "TextLabel %p EllipsisPosition::Type %d\n", impl.mController.Get(), ellipsisPositionType); + impl.mController->SetEllipsisPosition(ellipsisPositionType); + } + break; + } + case Toolkit::DevelTextLabel::Property::STRIKETHROUGH: + { + impl.mTextUpdateNeeded = SetStrikethroughProperties(impl.mController, value, Text::EffectStyle::DEFAULT) || impl.mTextUpdateNeeded; + break; + } + case Toolkit::DevelTextLabel::Property::CHARACTER_SPACING: + { + const float characterSpacing = value.Get(); + impl.mController->SetCharacterSpacing(characterSpacing); + break; + } + case Toolkit::DevelTextLabel::Property::RELATIVE_LINE_SIZE: + { + const float relativeLineSize = value.Get(); + DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextLabel %p RELATIVE_LINE_SIZE %f\n", impl.mController.Get(), relativeLineSize); + + impl.mController->SetRelativeLineSize(relativeLineSize); + break; + } } // Request relayout when text update is needed. It's necessary to call it @@ -491,7 +563,7 @@ void TextLabel::SetProperty(BaseObject* object, Property::Index index, const Pro } } -Text::ControllerPtr TextLabel::getController() +Text::ControllerPtr TextLabel::GetTextController() { return mController; } @@ -684,21 +756,23 @@ Property::Value TextLabel::GetProperty(BaseObject* object, Property::Index index } case Toolkit::DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION: { - value = impl.mController->IsMatchSystemLanguageDirection(); + value = impl.mController->GetMatchLayoutDirection() != DevelText::MatchLayoutDirection::CONTENTS; break; } case Toolkit::DevelTextLabel::Property::TEXT_FIT: { - const bool enabled = impl.mController->IsTextFitEnabled(); - const float minSize = impl.mController->GetTextFitMinSize(); - const float maxSize = impl.mController->GetTextFitMaxSize(); - const float stepSize = impl.mController->GetTextFitStepSize(); + const bool enabled = impl.mController->IsTextFitEnabled(); + const float minSize = impl.mController->GetTextFitMinSize(); + const float maxSize = impl.mController->GetTextFitMaxSize(); + const float stepSize = impl.mController->GetTextFitStepSize(); + const float pointSize = impl.mController->GetTextFitPointSize(); Property::Map map; map.Insert(TEXT_FIT_ENABLE_KEY, enabled); map.Insert(TEXT_FIT_MIN_SIZE_KEY, minSize); map.Insert(TEXT_FIT_MAX_SIZE_KEY, maxSize); map.Insert(TEXT_FIT_STEP_SIZE_KEY, stepSize); + map.Insert(TEXT_FIT_FONT_SIZE_KEY, pointSize); map.Insert(TEXT_FIT_FONT_SIZE_TYPE_KEY, "pointSize"); value = map; @@ -714,12 +788,79 @@ Property::Value TextLabel::GetProperty(BaseObject* object, Property::Index index value = impl.mController->GetFontSizeScale(); break; } + case Toolkit::DevelTextLabel::Property::ENABLE_FONT_SIZE_SCALE: + { + value = impl.mController->IsFontSizeScaleEnabled(); + break; + } + case Toolkit::DevelTextLabel::Property::ELLIPSIS_POSITION: + { + value = impl.mController->GetEllipsisPosition(); + break; + } + case Toolkit::DevelTextLabel::Property::STRIKETHROUGH: + { + GetStrikethroughProperties(impl.mController, value, Text::EffectStyle::DEFAULT); + break; + } + case Toolkit::DevelTextLabel::Property::CHARACTER_SPACING: + { + value = impl.mController->GetCharacterSpacing(); + break; + } + case Toolkit::DevelTextLabel::Property::RELATIVE_LINE_SIZE: + { + value = impl.mController->GetRelativeLineSize(); + break; + } } } return value; } +bool TextLabel::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor) +{ + Dali::BaseHandle handle(object); + + bool connected(true); + Toolkit::TextLabel label = Toolkit::TextLabel::DownCast(handle); + + if(0 == strcmp(signalName.c_str(), SIGNAL_ANCHOR_CLICKED)) + { + if(label) + { + Internal::TextLabel& labelImpl(GetImpl(label)); + labelImpl.AnchorClickedSignal().Connect(tracker, functor); + } + } + else if(0 == strcmp(signalName.c_str(), SIGNAL_TEXT_FIT_CHANGED)) + { + if(label) + { + Internal::TextLabel& labelImpl(GetImpl(label)); + labelImpl.TextFitChangedSignal().Connect(tracker, functor); + } + } + else + { + // signalName does not match any signal + connected = false; + } + + return connected; +} + +DevelTextLabel::AnchorClickedSignalType& TextLabel::AnchorClickedSignal() +{ + return mAnchorClickedSignal; +} + +DevelTextLabel::TextFitChangedSignalType& TextLabel::TextFitChangedSignal() +{ + return mTextFitChangedSignal; +} + void TextLabel::OnInitialize() { Actor self = Self(); @@ -736,14 +877,12 @@ void TextLabel::OnInitialize() DALI_ASSERT_DEBUG(mController && "Invalid Text Controller") mController->SetControlInterface(this); + mController->SetAnchorControlInterface(this); // Use height-for-width negotiation by default self.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH); self.SetResizePolicy(ResizePolicy::DIMENSION_DEPENDENCY, Dimension::HEIGHT); - // Enable highlightability - self.SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true); - // Enable the text ellipsis. mController->SetTextElideEnabled(true); // If false then text larger than control will overflow @@ -752,13 +891,22 @@ void TextLabel::OnInitialize() Dali::LayoutDirection::Type layoutDirection = static_cast(stage.GetRootLayer().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get()); mController->SetLayoutDirection(layoutDirection); + self.LayoutDirectionChangedSignal().Connect(this, &TextLabel::OnLayoutDirectionChanged); + Layout::Engine& engine = mController->GetLayoutEngine(); engine.SetCursorWidth(0u); // Do not layout space for the cursor. - DevelControl::SetAccessibilityConstructor(self, [](Dali::Actor actor) { - return std::unique_ptr( - new AccessibleImpl(actor, Dali::Accessibility::Role::LABEL)); - }); + // Accessibility + self.SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::LABEL); + self.SetProperty(DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true); + + Accessibility::Bridge::EnabledSignal().Connect(this, &TextLabel::OnAccessibilityStatusChanged); + Accessibility::Bridge::DisabledSignal().Connect(this, &TextLabel::OnAccessibilityStatusChanged); +} + +DevelControl::ControlAccessible* TextLabel::CreateAccessibleObject() +{ + return new TextLabelAccessible(Self()); } void TextLabel::OnStyleChange(Toolkit::StyleManager styleManager, StyleChange::Type change) @@ -793,6 +941,23 @@ void TextLabel::OnStyleChange(Toolkit::StyleManager styleManager, StyleChange::T Control::OnStyleChange(styleManager, change); } +void TextLabel::OnTap(const TapGesture& gesture) +{ + DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextLabel::OnTap %p\n", mController.Get()); + + // Deliver the tap before the focus event to controller; this allows us to detect when focus is gained due to tap-gestures + Extents padding; + padding = Self().GetProperty(Toolkit::Control::Property::PADDING); + const Vector2& localPoint = gesture.GetLocalPoint(); + mController->AnchorEvent(localPoint.x - padding.start, localPoint.y - padding.top); +} + +void TextLabel::AnchorClicked(const std::string& href) +{ + Dali::Toolkit::TextLabel handle(GetOwner()); + mAnchorClickedSignal.Emit(handle, href.c_str(), href.length()); +} + Vector3 TextLabel::GetNaturalSize() { Extents padding; @@ -829,6 +994,12 @@ void TextLabel::OnPropertySet(Property::Index index, const Property::Value& prop } break; } + case Toolkit::TextLabel::Property::TEXT: + case Toolkit::TextLabel::Property::ENABLE_MARKUP: + { + CommonTextUtils::SynchronizeTextAnchorsInParent(Self(), mController, mAnchorActors); + break; + } default: { Control::OnPropertySet(index, propertyValue); // up call to control for non-handled properties @@ -841,8 +1012,10 @@ void TextLabel::OnRelayout(const Vector2& size, RelayoutContainer& container) { DALI_LOG_INFO(gLogFilter, Debug::General, "TextLabel::OnRelayout\n"); + Actor self = Self(); + Extents padding; - padding = Self().GetProperty(Toolkit::Control::Property::PADDING); + padding = self.GetProperty(Toolkit::Control::Property::PADDING); Vector2 contentSize(size.x - (padding.start + padding.end), size.y - (padding.top + padding.bottom)); @@ -853,15 +1026,8 @@ void TextLabel::OnRelayout(const Vector2& size, RelayoutContainer& container) } // Support Right-To-Left - Dali::LayoutDirection::Type layoutDirection; - if(mController->IsMatchSystemLanguageDirection()) - { - layoutDirection = static_cast(DevelWindow::Get(Self()).GetRootLayer().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get()); - } - else - { - layoutDirection = static_cast(Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get()); - } + Dali::LayoutDirection::Type layoutDirection = mController->GetLayoutDirection(self); + const Text::Controller::UpdateTextType updateTextType = mController->Relayout(contentSize, layoutDirection); if((Text::Controller::NONE_UPDATED != (Text::Controller::MODEL_UPDATED & updateTextType)) || mTextUpdateNeeded) @@ -912,6 +1078,12 @@ void TextLabel::OnRelayout(const Vector2& size, RelayoutContainer& container) mTextUpdateNeeded = false; } + + if(mController->IsTextFitChanged()) + { + EmitTextFitChangedSignal(); + mController->SetTextFitChanged(false); + } } void TextLabel::RequestTextRelayout() @@ -953,6 +1125,7 @@ void TextLabel::SetUpAutoScrolling() if(textNaturalSize.width > maxTextureSize) { mController->SetTextElideEnabled(true); + mController->SetAutoScrollMaxTextureExceeded(true); } GetHeightForWidth(maxTextureSize); wrapGap = std::max(maxTextureSize - textNaturalSize.width, 0.0f); @@ -980,6 +1153,7 @@ void TextLabel::SetUpAutoScrolling() Renderer renderer = static_cast(GetImplementation(mVisual)).GetRenderer(); mTextScroller->SetParameters(Self(), renderer, textureSet, controlSize, verifiedSize, wrapGap, direction, mController->GetHorizontalAlignment(), mController->GetVerticalAlignment()); mController->SetTextElideEnabled(actualellipsis); + mController->SetAutoScrollMaxTextureExceeded(false); } void TextLabel::ScrollingFinished() @@ -990,178 +1164,65 @@ void TextLabel::ScrollingFinished() RequestTextRelayout(); } -TextLabel::TextLabel() -: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)), - mRenderingBackend(DEFAULT_RENDERING_BACKEND), - mTextUpdateNeeded(false) +void TextLabel::OnLayoutDirectionChanged(Actor actor, LayoutDirection::Type type) { + mController->ChangedLayoutDirection(); } -TextLabel::~TextLabel() +void TextLabel::EmitTextFitChangedSignal() { + Dali::Toolkit::TextLabel handle(GetOwner()); + mTextFitChangedSignal.Emit(handle); } -std::string TextLabel::AccessibleImpl::GetNameRaw() +void TextLabel::OnAccessibilityStatusChanged() { - auto slf = Toolkit::TextLabel::DownCast(self); - return slf.GetProperty(Toolkit::TextLabel::Property::TEXT).Get(); + CommonTextUtils::SynchronizeTextAnchorsInParent(Self(), mController, mAnchorActors); } -Property::Index TextLabel::AccessibleImpl::GetNamePropertyIndex() +TextLabel::TextLabel(ControlBehaviour additionalBehavior) +: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehavior)), + mRenderingBackend(DEFAULT_RENDERING_BACKEND), + mTextUpdateNeeded(false) { - return Toolkit::TextLabel::Property::TEXT; } -std::string TextLabel::AccessibleImpl::GetText(size_t startOffset, - size_t endOffset) +TextLabel::~TextLabel() { - if(endOffset <= startOffset) - return {}; - - auto slf = Toolkit::TextLabel::DownCast(self); - auto txt = - slf.GetProperty(Toolkit::TextLabel::Property::TEXT).Get(); - - if(startOffset > txt.size() || endOffset > txt.size()) - return {}; - - return txt.substr(startOffset, endOffset - startOffset); } -size_t TextLabel::AccessibleImpl::GetCharacterCount() +Vector TextLabel::GetTextSize(const uint32_t startIndex, const uint32_t endIndex) const { - auto slf = Toolkit::TextLabel::DownCast(self); - auto txt = - slf.GetProperty(Toolkit::TextLabel::Property::TEXT).Get(); - - return txt.size(); + return mController->GetTextSize(startIndex, endIndex); } -size_t TextLabel::AccessibleImpl::GetCaretOffset() +Vector TextLabel::GetTextPosition(const uint32_t startIndex, const uint32_t endIndex) const { - return {}; + return mController->GetTextPosition(startIndex, endIndex); } -bool TextLabel::AccessibleImpl::SetCaretOffset(size_t offset) +std::string TextLabel::TextLabelAccessible::GetNameRaw() const { - return {}; + return GetWholeText(); } -Dali::Accessibility::Range TextLabel::AccessibleImpl::GetTextAtOffset( - size_t offset, Dali::Accessibility::TextBoundary boundary) +Property::Index TextLabel::TextLabelAccessible::GetNamePropertyIndex() { - auto slf = Toolkit::TextLabel::DownCast(self); - auto txt = slf.GetProperty(Toolkit::TextLabel::Property::TEXT).Get(); - auto txt_size = txt.size(); - - auto range = Dali::Accessibility::Range{}; - - switch(boundary) - { - case Dali::Accessibility::TextBoundary::CHARACTER: - { - if(offset < txt_size) - { - range.content = txt[offset]; - range.startOffset = offset; - range.endOffset = offset + 1; - } - } - break; - case Dali::Accessibility::TextBoundary::WORD: - case Dali::Accessibility::TextBoundary::LINE: - { - auto txt_c_string = txt.c_str(); - auto breaks = std::vector(txt_size, 0); - if(boundary == Dali::Accessibility::TextBoundary::WORD) - Accessibility::Accessible::FindWordSeparationsUtf8((const utf8_t*)txt_c_string, txt_size, "", breaks.data()); - else - Accessibility::Accessible::FindLineSeparationsUtf8((const utf8_t*)txt_c_string, txt_size, "", breaks.data()); - auto index = 0u; - auto counter = 0u; - while(index < txt_size && counter <= offset) - { - auto start = index; - if(breaks[index]) - { - while(breaks[index]) - index++; - counter++; - } - else - { - if(boundary == Dali::Accessibility::TextBoundary::WORD) - index++; - if(boundary == Dali::Accessibility::TextBoundary::LINE) - counter++; - } - if((counter > 0) && ((counter - 1) == offset)) - { - range.content = txt.substr(start, index - start + 1); - range.startOffset = start; - range.endOffset = index + 1; - } - if(boundary == Dali::Accessibility::TextBoundary::LINE) - index++; - } - } - break; - case Dali::Accessibility::TextBoundary::SENTENCE: - { - /* not supported by efl */ - } - break; - case Dali::Accessibility::TextBoundary::PARAGRAPH: - { - /* Paragraph is not supported by libunibreak library */ - } - break; - default: - break; - } - - return range; + return Toolkit::TextLabel::Property::TEXT; } -Dali::Accessibility::Range -TextLabel::AccessibleImpl::GetSelection(size_t selectionNum) +const std::vector& TextLabel::TextLabelAccessible::GetTextAnchors() const { - // Since DALi supports only one selection indexes higher than 0 are ignored - if(selectionNum > 0) - return {}; + auto self = Toolkit::TextLabel::DownCast(Self()); - auto slf = Toolkit::TextLabel::DownCast(self); - auto ctrl = Dali::Toolkit::GetImpl(slf).getController(); - std::string ret; - ctrl->RetrieveSelection(ret); - auto r = ctrl->GetSelectionIndexes(); - - return {static_cast(r.first), static_cast(r.second), ret}; + return Toolkit::GetImpl(self).mAnchorActors; } -bool TextLabel::AccessibleImpl::RemoveSelection(size_t selectionNum) +Toolkit::Text::ControllerPtr TextLabel::TextLabelAccessible::GetTextController() const { - // Since DALi supports only one selection indexes higher than 0 are ignored - if(selectionNum > 0) - return false; - - auto slf = Toolkit::TextLabel::DownCast(self); - Dali::Toolkit::GetImpl(slf).getController()->SetSelection(0, 0); - return true; -} + auto self = Toolkit::TextLabel::DownCast(Self()); -bool TextLabel::AccessibleImpl::SetSelection(size_t selectionNum, - size_t startOffset, - size_t endOffset) -{ - // Since DALi supports only one selection indexes higher than 0 are ignored - if(selectionNum > 0) - return false; - - auto slf = Toolkit::TextLabel::DownCast(self); - Dali::Toolkit::GetImpl(slf).getController()->SetSelection(startOffset, - endOffset); - return true; + return Toolkit::GetImpl(self).GetTextController(); } } // namespace Internal