/*
- * 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.
#include <dali-toolkit/internal/controls/text-controls/text-label-impl.h>
// EXTERNAL INCLUDES
+#include <dali/devel-api/actors/actor-devel.h>
#include <dali/devel-api/adaptor-framework/image-loading.h>
-#include <dali/devel-api/adaptor-framework/window-devel.h>
#include <dali/devel-api/common/stage.h>
#include <dali/devel-api/object/property-helper-devel.h>
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
#include <dali-toolkit/devel-api/text/rendering-backend.h>
+#include <dali-toolkit/internal/controls/text-controls/common-text-utils.h>
#include <dali-toolkit/internal/styling/style-manager-impl.h>
#include <dali-toolkit/internal/text/property-string-parser.h>
#include <dali-toolkit/internal/text/rendering/text-backend.h>
#include <dali-toolkit/public-api/visuals/text-visual-properties.h>
#include <dali-toolkit/public-api/visuals/visual-properties.h>
+// DEVEL INCLUDES
#include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
using namespace Dali::Toolkit::Text;
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)
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
} // namespace
-Toolkit::TextLabel TextLabel::New()
+Toolkit::TextLabel TextLabel::New(ControlBehaviour additionalBehaviour)
{
// Create the implementation, temporarily owned by this handle on stack
- IntrusivePtr<TextLabel> impl = new TextLabel();
+ IntrusivePtr<TextLabel> impl = new TextLabel(additionalBehaviour);
// Pass ownership to CustomActor handle
Toolkit::TextLabel handle(*impl);
case Toolkit::TextLabel::Property::TEXT:
{
impl.mController->SetText(value.Get<std::string>());
+
+ if(impl.mController->HasAnchors())
+ {
+ // Forward input events to controller
+ impl.EnableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP));
+ }
+ else
+ {
+ impl.DisableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP));
+ }
+
break;
}
case Toolkit::TextLabel::Property::FONT_FAMILY:
{
const bool enableMarkup = value.Get<bool>();
impl.mController->SetMarkupProcessorEnabled(enableMarkup);
+
+ if(impl.mController->HasAnchors())
+ {
+ // Forward input events to controller
+ impl.EnableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP));
+ }
+ else
+ {
+ impl.DisableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP));
+ }
break;
}
case Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL:
}
case Toolkit::DevelTextLabel::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
{
- impl.mController->SetMatchSystemLanguageDirection(value.Get<bool>());
+ impl.mController->SetMatchLayoutDirection(value.Get<bool>() ? 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:
}
break;
}
+ case Toolkit::DevelTextLabel::Property::ENABLE_FONT_SIZE_SCALE:
+ {
+ const bool enableFontSizeScale = value.Get<bool>();
+ if(!Equals(impl.mController->IsFontSizeScaleEnabled(), enableFontSizeScale))
+ {
+ impl.mController->SetFontSizeScaleEnabled(enableFontSizeScale);
+ }
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::ELLIPSIS_POSITION:
+ {
+ DevelText::EllipsisPosition::Type ellipsisPositionType(static_cast<DevelText::EllipsisPosition::Type>(-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<float>();
+ impl.mController->SetCharacterSpacing(characterSpacing);
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::RELATIVE_LINE_SIZE:
+ {
+ const float relativeLineSize = value.Get<float>();
+ 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
}
}
-Text::ControllerPtr TextLabel::getController()
+Text::ControllerPtr TextLabel::GetTextController()
{
return mController;
}
}
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;
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();
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
Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(stage.GetRootLayer().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
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<Dali::Accessibility::Accessible>(
- 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)
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<Extents>(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;
}
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
{
DALI_LOG_INFO(gLogFilter, Debug::General, "TextLabel::OnRelayout\n");
+ Actor self = Self();
+
Extents padding;
- padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
+ padding = self.GetProperty<Extents>(Toolkit::Control::Property::PADDING);
Vector2 contentSize(size.x - (padding.start + padding.end), size.y - (padding.top + padding.bottom));
}
// Support Right-To-Left
- Dali::LayoutDirection::Type layoutDirection;
- if(mController->IsMatchSystemLanguageDirection())
- {
- layoutDirection = static_cast<Dali::LayoutDirection::Type>(DevelWindow::Get(Self()).GetRootLayer().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
- }
- else
- {
- layoutDirection = static_cast<Dali::LayoutDirection::Type>(Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
- }
+ 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)
mTextUpdateNeeded = false;
}
+
+ if(mController->IsTextFitChanged())
+ {
+ EmitTextFitChangedSignal();
+ mController->SetTextFitChanged(false);
+ }
}
void TextLabel::RequestTextRelayout()
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<std::string>();
+ 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<std::string>();
-
- if(startOffset > txt.size() || endOffset > txt.size())
- return {};
-
- return txt.substr(startOffset, endOffset - startOffset);
}
-size_t TextLabel::AccessibleImpl::GetCharacterCount()
+Vector<Vector2> 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<std::string>();
-
- return txt.size();
+ return mController->GetTextSize(startIndex, endIndex);
}
-size_t TextLabel::AccessibleImpl::GetCaretOffset()
+Vector<Vector2> 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<std::string>();
- 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<char>(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<Toolkit::TextAnchor>& 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<size_t>(r.first), static_cast<size_t>(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