#include <dali/devel-api/adaptor-framework/image-loading.h>
#include <dali/devel-api/common/stage.h>
#include <dali/devel-api/object/property-helper-devel.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <dali/integration-api/debug.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/object/type-registry-helper.h>
* The alignment depends on the alignment value of the text label (Use Text::VerticalAlignment enumerations).
*/
const float VERTICAL_ALIGNMENT_TABLE[Text::VerticalAlignment::BOTTOM + 1] =
- {
+{
0.0f, // VerticalAlignment::TOP
0.5f, // VerticalAlignment::CENTER
1.0f // VerticalAlignment::BOTTOM
};
-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");
+const char* TEXT_FIT_ENABLE_KEY("enable");
+const char* TEXT_FIT_MIN_SIZE_KEY("minSize");
+const char* TEXT_FIT_MAX_SIZE_KEY("maxSize");
+const char* TEXT_FIT_STEP_SIZE_KEY("stepSize");
+const char* TEXT_FIT_FONT_SIZE_KEY("fontSize");
+const char* TEXT_FIT_FONT_SIZE_TYPE_KEY("fontSizeType");
#if defined(DEBUG_ENABLED)
Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
#endif
const Scripting::StringEnum AUTO_SCROLL_STOP_MODE_TABLE[] =
- {
+{
{"IMMEDIATE", Toolkit::TextLabel::AutoScrollStopMode::IMMEDIATE},
{"FINISH_LOOP", Toolkit::TextLabel::AutoScrollStopMode::FINISH_LOOP},
};
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_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "anchorColor", VECTOR4, ANCHOR_COLOR )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "anchorClickedColor", VECTOR4, ANCHOR_CLICKED_COLOR )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "removeFrontInset", BOOLEAN, REMOVE_FRONT_INSET )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextLabel, "removeBackInset", BOOLEAN, REMOVE_BACK_INSET )
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)
}
controller->SetTextFitEnabled(enabled);
+ // The TextFit operation is performed based on the MinLineSize set in the TextLabel at the moment when the TextFit property is set.
+ // So, if you change the TextLabel's MinLineSize after setting the TextFit property, it does not affect the operation of TextFit.
+ // This may require a new LineSize item in TextFit.
+ controller->SetTextFitLineSize(controller->GetDefaultLineSize());
if(isMinSizeSet)
{
controller->SetTextFitMinSize(minSize, type);
case Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL:
{
const bool enableAutoScroll = value.Get<bool>();
+ impl.mLastAutoScrollEnabled = enableAutoScroll;
// If request to auto scroll is the same as current state then do nothing.
if(enableAutoScroll != impl.mController->IsAutoScrollEnabled())
{
}
case Toolkit::DevelTextLabel::Property::TEXT_FIT:
{
+ // If TextFitArray is enabled, this should be disabled.
+ if(impl.mController->IsTextFitArrayEnabled())
+ {
+ impl.mController->SetDefaultLineSize(impl.mController->GetCurrentLineSize());
+ impl.mController->SetTextFitArrayEnabled(false);
+ }
+
ParseTextFitProperty(impl.mController, value.GetMap());
impl.mController->SetTextFitChanged(true);
break;
}
case Toolkit::DevelTextLabel::Property::MIN_LINE_SIZE:
{
- const float lineSize = value.Get<float>();
- impl.mTextUpdateNeeded = impl.mController->SetDefaultLineSize(lineSize) || impl.mTextUpdateNeeded;
+ const float lineSize = value.Get<float>();
+ // If TextFitArray is enabled, do not update the default line size.
+ if(!impl.mController->IsTextFitArrayEnabled())
+ {
+ impl.mTextUpdateNeeded = impl.mController->SetDefaultLineSize(lineSize) || impl.mTextUpdateNeeded;
+ }
+ impl.mController->SetCurrentLineSize(lineSize);
break;
}
case Toolkit::DevelTextLabel::Property::FONT_SIZE_SCALE:
impl.mController->SetRelativeLineSize(relativeLineSize);
break;
}
+ case Toolkit::DevelTextLabel::Property::ANCHOR_COLOR:
+ {
+ const Vector4& anchorColor = value.Get<Vector4>();
+ if(impl.mController->GetAnchorColor() != anchorColor)
+ {
+ impl.mController->SetAnchorColor(anchorColor);
+ impl.mTextUpdateNeeded = true;
+ }
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::ANCHOR_CLICKED_COLOR:
+ {
+ const Vector4& anchorClickedColor = value.Get<Vector4>();
+ if(impl.mController->GetAnchorClickedColor() != anchorClickedColor)
+ {
+ impl.mController->SetAnchorClickedColor(anchorClickedColor);
+ impl.mTextUpdateNeeded = true;
+ }
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::REMOVE_FRONT_INSET:
+ {
+ const bool remove = value.Get<bool>();
+ impl.mController->SetRemoveFrontInset(remove);
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::REMOVE_BACK_INSET:
+ {
+ const bool remove = value.Get<bool>();
+ impl.mController->SetRemoveBackInset(remove);
+ break;
+ }
}
// Request relayout when text update is needed. It's necessary to call it
}
case Toolkit::DevelTextLabel::Property::MIN_LINE_SIZE:
{
- value = impl.mController->GetDefaultLineSize();
+ // If TextFitArray is enabled, the stored value (MIN_LINE_SIZE set by the user) is retrun.
+ value = impl.mController->IsTextFitArrayEnabled() ? impl.mController->GetCurrentLineSize() : impl.mController->GetDefaultLineSize();
break;
}
case Toolkit::DevelTextLabel::Property::FONT_SIZE_SCALE:
value = impl.mController->GetRelativeLineSize();
break;
}
+ case Toolkit::DevelTextLabel::Property::ANCHOR_COLOR:
+ {
+ value = impl.mController->GetAnchorColor();
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::ANCHOR_CLICKED_COLOR:
+ {
+ value = impl.mController->GetAnchorClickedColor();
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::REMOVE_FRONT_INSET:
+ {
+ value = impl.mController->IsRemoveFrontInset();
+ break;
+ }
+ case Toolkit::DevelTextLabel::Property::REMOVE_BACK_INSET:
+ {
+ value = impl.mController->IsRemoveBackInset();
+ break;
+ }
}
}
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
self.LayoutDirectionChangedSignal().Connect(this, &TextLabel::OnLayoutDirectionChanged);
+ if(Dali::Adaptor::IsAvailable())
+ {
+ Dali::Adaptor::Get().LocaleChangedSignal().Connect(this, &TextLabel::OnLocaleChanged);
+ }
+
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)
{
DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextLabel::OnStyleChange\n");
}
}
+void TextLabel::OnSceneConnection(int depth)
+{
+ if(mController->IsAutoScrollEnabled() || mLastAutoScrollEnabled)
+ {
+ mController->SetAutoScrollEnabled(true);
+ }
+ Control::OnSceneConnection(depth);
+}
+
+void TextLabel::OnSceneDisconnection()
+{
+ if(mTextScroller)
+ {
+ if(mLastAutoScrollEnabled && !mController->IsAutoScrollEnabled())
+ {
+ mLastAutoScrollEnabled = false;
+ }
+
+ const Toolkit::TextLabel::AutoScrollStopMode::Type stopMode = mTextScroller->GetStopMode();
+ mTextScroller->SetStopMode(Toolkit::TextLabel::AutoScrollStopMode::IMMEDIATE);
+ mTextScroller->StopScrolling();
+ mTextScroller->SetStopMode(stopMode);
+ }
+ Control::OnSceneDisconnection();
+}
+
void TextLabel::OnRelayout(const Vector2& size, RelayoutContainer& container)
{
DALI_LOG_INFO(gLogFilter, Debug::General, "TextLabel::OnRelayout\n");
Vector2 contentSize(size.x - (padding.start + padding.end), size.y - (padding.top + padding.bottom));
- if(mController->IsTextFitEnabled())
+ if(mController->IsTextFitArrayEnabled())
+ {
+ mController->FitArrayPointSizeforLayout(contentSize);
+ mController->SetTextFitContentSize(contentSize);
+ }
+ else if(mController->IsTextFitEnabled())
{
mController->FitPointSizeforLayout(contentSize);
mController->SetTextFitContentSize(contentSize);
alignmentOffset.x = 0.0f;
alignmentOffset.y = (contentSize.y - layoutSize.y) * VERTICAL_ALIGNMENT_TABLE[mController->GetVerticalAlignment()];
+ const int maxTextureSize = Dali::GetMaxTextureSize();
+ if(layoutSize.width > maxTextureSize)
+ {
+ DALI_LOG_WARNING("layoutSize(%f) > maxTextureSize(%d): To guarantee the behavior of Texture::New, layoutSize must not be bigger than maxTextureSize\n", layoutSize.width, maxTextureSize);
+ layoutSize.width = maxTextureSize;
+ }
+
+ // This affects font rendering quality.
+ // It need to be integerized.
+ Vector2 visualTransformOffset;
+ visualTransformOffset.x = roundf(padding.start + alignmentOffset.x);
+ visualTransformOffset.y = roundf(padding.top + alignmentOffset.y);
+
+ mController->SetVisualTransformOffset(visualTransformOffset);
+
Property::Map visualTransform;
visualTransform.Add(Toolkit::Visual::Transform::Property::SIZE, layoutSize)
.Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
- .Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2(padding.start, padding.top) + alignmentOffset)
+ .Add(Toolkit::Visual::Transform::Property::OFFSET, visualTransformOffset)
.Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE))
.Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
.Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN);
if(textNaturalSize.width > maxTextureSize)
{
mController->SetTextElideEnabled(true);
+ mController->SetAutoScrollMaxTextureExceeded(true);
}
GetHeightForWidth(maxTextureSize);
wrapGap = std::max(maxTextureSize - textNaturalSize.width, 0.0f);
Renderer renderer = static_cast<Internal::Visual::Base&>(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()
{
// Pure Virtual from TextScroller Interface
DALI_LOG_INFO(gLogFilter, Debug::General, "TextLabel::ScrollingFinished\n");
- mController->SetAutoScrollEnabled(false);
- RequestTextRelayout();
+
+ if(mController->IsAutoScrollEnabled() || !mController->IsMultiLineEnabled())
+ {
+ mController->SetAutoScrollEnabled(false);
+ RequestTextRelayout();
+ }
}
void TextLabel::OnLayoutDirectionChanged(Actor actor, LayoutDirection::Type type)
mController->ChangedLayoutDirection();
}
+void TextLabel::OnLocaleChanged(std::string locale)
+{
+ if(mLocale != locale)
+ {
+ mLocale = locale;
+ mController->ResetFontAndStyleData();
+ }
+}
+
+std::string TextLabel::GetLocale()
+{
+ return mLocale;
+}
+
void TextLabel::EmitTextFitChangedSignal()
{
Dali::Toolkit::TextLabel handle(GetOwner());
CommonTextUtils::SynchronizeTextAnchorsInParent(Self(), mController, mAnchorActors);
}
-TextLabel::TextLabel(ControlBehaviour additionalBehavior)
-: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehavior)),
+TextLabel::TextLabel(ControlBehaviour additionalBehaviour)
+: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT | additionalBehaviour)),
+ mLocale(std::string()),
mRenderingBackend(DEFAULT_RENDERING_BACKEND),
- mTextUpdateNeeded(false)
+ mTextUpdateNeeded(false),
+ mLastAutoScrollEnabled(false)
{
}
return mController->GetTextPosition(startIndex, endIndex);
}
-std::string TextLabel::AccessibleImpl::GetNameRaw() const
+Rect<float> TextLabel::GetLineBoundingRectangle(const uint32_t lineIndex) const
{
- auto self = Toolkit::TextLabel::DownCast(Self());
- return self.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
+ return mController->GetLineBoundingRectangle(lineIndex);
}
-Property::Index TextLabel::AccessibleImpl::GetNamePropertyIndex()
+Rect<float> TextLabel::GetCharacterBoundingRectangle(const uint32_t charIndex) const
{
- return Toolkit::TextLabel::Property::TEXT;
+ return mController->GetCharacterBoundingRectangle(charIndex);
}
-std::string TextLabel::AccessibleImpl::GetText(size_t startOffset, size_t endOffset) const
+int TextLabel::GetCharacterIndexAtPosition(float visualX, float visualY) const
{
- if(endOffset <= startOffset)
- {
- return {};
- }
+ return mController->GetCharacterIndexAtPosition(visualX, visualY);
+}
- auto self = Toolkit::TextLabel::DownCast(Self());
- auto text = self.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
+Rect<> TextLabel::GetTextBoundingRectangle(uint32_t startIndex, uint32_t endIndex) const
+{
+ return mController->GetTextBoundingRectangle(startIndex, endIndex);
+}
- if(startOffset > text.size() || endOffset > text.size())
+void TextLabel::SetSpannedText(const Text::Spanned& spannedText)
+{
+ mController->SetSpannedText(spannedText);
+}
+
+void TextLabel::SetTextFitArray(const bool enable, std::vector<Toolkit::DevelTextLabel::FitOption>& fitOptions)
+{
+ if(!enable)
{
- return {};
+ // If TextFitArray is disabled, MinLineSize shoud be restored to its original size.
+ mController->SetDefaultLineSize(mController->GetCurrentLineSize());
}
-
- return text.substr(startOffset, endOffset - startOffset);
+ mController->SetTextFitArrayEnabled(enable);
+ mController->SetTextFitArray(fitOptions);
}
-size_t TextLabel::AccessibleImpl::GetCharacterCount() const
+std::vector<Toolkit::DevelTextLabel::FitOption>& TextLabel::GetTextFitArray()
{
- auto self = Toolkit::TextLabel::DownCast(Self());
- auto text = self.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
-
- return text.size();
+ return mController->GetTextFitArray();
}
-size_t TextLabel::AccessibleImpl::GetCursorOffset() const
+bool TextLabel::IsTextFitArrayEnabled() const
{
- return {};
+ return mController->IsTextFitArrayEnabled();
}
-bool TextLabel::AccessibleImpl::SetCursorOffset(size_t offset)
+void TextLabel::SetRemoveFrontInset(bool remove)
{
- return {};
+ mController->SetRemoveFrontInset(remove);
}
-Dali::Accessibility::Range TextLabel::AccessibleImpl::GetTextAtOffset(size_t offset, Dali::Accessibility::TextBoundary boundary) const
+bool TextLabel::IsRemoveFrontInset() const
{
- auto self = Toolkit::TextLabel::DownCast(Self());
- auto text = self.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
- auto textSize = text.size();
-
- auto range = Dali::Accessibility::Range{};
-
- switch(boundary)
- {
- case Dali::Accessibility::TextBoundary::CHARACTER:
- {
- if(offset < textSize)
- {
- range.content = text[offset];
- range.startOffset = offset;
- range.endOffset = offset + 1;
- }
- break;
- }
- case Dali::Accessibility::TextBoundary::WORD:
- case Dali::Accessibility::TextBoundary::LINE:
- {
- auto textString = text.c_str();
- auto breaks = std::vector<char>(textSize, 0);
-
- if(boundary == Dali::Accessibility::TextBoundary::WORD)
- {
- Accessibility::Accessible::FindWordSeparationsUtf8(reinterpret_cast<const utf8_t*>(textString), textSize, "", breaks.data());
- }
- else
- {
- Accessibility::Accessible::FindLineSeparationsUtf8(reinterpret_cast<const utf8_t*>(textString), textSize, "", breaks.data());
- }
-
- auto index = 0u;
- auto counter = 0u;
- while(index < textSize && 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 = text.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 default */
- break;
- }
- case Dali::Accessibility::TextBoundary::PARAGRAPH:
- {
- /* Paragraph is not supported by libunibreak library */
- break;
- }
- default:
- break;
- }
-
- return range;
+ return mController->IsRemoveFrontInset();
}
-Dali::Accessibility::Range TextLabel::AccessibleImpl::GetRangeOfSelection(size_t selectionIndex) const
+void TextLabel::SetRemoveBackInset(bool remove)
{
- // Since DALi supports only one selection indexes higher than 0 are ignored
- if(selectionIndex > 0)
- {
- return {};
- }
-
- auto self = Toolkit::TextLabel::DownCast(Self());
- auto controller = Dali::Toolkit::GetImpl(self).GetTextController();
- std::string value{};
- controller->RetrieveSelection(value);
- auto indices = controller->GetSelectionIndexes();
-
- return {static_cast<size_t>(indices.first), static_cast<size_t>(indices.second), value};
+ mController->SetRemoveBackInset(remove);
}
-bool TextLabel::AccessibleImpl::RemoveSelection(size_t selectionIndex)
+bool TextLabel::IsRemoveBackInset() const
{
- // Since DALi supports only one selection indexes higher than 0 are ignored
- if(selectionIndex > 0)
- {
- return false;
- }
-
- auto self = Toolkit::TextLabel::DownCast(Self());
- Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(0, 0);
- return true;
+ return mController->IsRemoveBackInset();
}
-bool TextLabel::AccessibleImpl::SetRangeOfSelection(size_t selectionIndex, size_t startOffset, size_t endOffset)
+std::string TextLabel::TextLabelAccessible::GetNameRaw() const
{
- // Since DALi supports only one selection indexes higher than 0 are ignored
- if(selectionIndex > 0)
- {
- return false;
- }
-
- auto self = Toolkit::TextLabel::DownCast(Self());
- Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(startOffset, endOffset);
- return true;
+ return GetWholeText();
}
-int32_t TextLabel::AccessibleImpl::GetLinkCount() const
+Property::Index TextLabel::TextLabelAccessible::GetNamePropertyIndex()
{
- auto self = Toolkit::TextLabel::DownCast(Self());
- return Dali::Toolkit::GetImpl(self).mAnchorActors.size();
+ return Toolkit::TextLabel::Property::TEXT;
}
-Accessibility::Hyperlink* TextLabel::AccessibleImpl::GetLink(int32_t linkIndex) const
+const std::vector<Toolkit::TextAnchor>& TextLabel::TextLabelAccessible::GetTextAnchors() const
{
- if(linkIndex < 0 || linkIndex >= GetLinkCount())
- {
- return nullptr;
- }
- auto self = Toolkit::TextLabel::DownCast(Self());
- auto anchorActor = Dali::Toolkit::GetImpl(self).mAnchorActors[linkIndex];
- return dynamic_cast<Accessibility::Hyperlink*>(Dali::Accessibility::Accessible::Get(anchorActor));
+ auto self = Toolkit::TextLabel::DownCast(Self());
+
+ return Toolkit::GetImpl(self).mAnchorActors;
}
-int32_t TextLabel::AccessibleImpl::GetLinkIndex(int32_t characterOffset) const
+Toolkit::Text::ControllerPtr TextLabel::TextLabelAccessible::GetTextController() const
{
- auto self = Toolkit::TextLabel::DownCast(Self());
- auto controller = Dali::Toolkit::GetImpl(self).GetTextController();
- return controller->GetAnchorIndex(static_cast<size_t>(characterOffset));
+ auto self = Toolkit::TextLabel::DownCast(Self());
+
+ return Toolkit::GetImpl(self).GetTextController();
}
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff