/*
- * 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.
// 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, "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::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::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;
+ }
}
}
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
return mAnchorClickedSignal;
}
+DevelTextLabel::TextFitChangedSignalType& TextLabel::TextFitChangedSignal()
+{
+ return mTextFitChangedSignal;
+}
+
void TextLabel::OnInitialize()
{
Actor self = Self();
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);
- // Forward input events to controller
- EnableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP));
- GetTapGestureDetector().SetMaximumTapsRequired(1);
-
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)
padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
const Vector2& localPoint = gesture.GetLocalPoint();
mController->AnchorEvent(localPoint.x - padding.start, localPoint.y - padding.top);
-
- // parents can also listen for tap gesture events
- Dali::DevelActor::SetNeedGesturePropagation(Self(), true);
}
void TextLabel::AnchorClicked(const std::string& href)
}
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
mTextUpdateNeeded = false;
}
+
+ if(mController->IsTextFitChanged())
+ {
+ EmitTextFitChangedSignal();
+ mController->SetTextFitChanged(false);
+ }
}
void TextLabel::RequestTextRelayout()
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()
mController->ChangedLayoutDirection();
}
-TextLabel::TextLabel()
-: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
- mRenderingBackend(DEFAULT_RENDERING_BACKEND),
- mTextUpdateNeeded(false)
-{
-}
-
-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 slf = Toolkit::TextLabel::DownCast(Self());
- auto ctrl = Dali::Toolkit::GetImpl(slf).getController();
- std::string ret;
- ctrl->RetrieveSelection(ret);
- auto r = ctrl->GetSelectionIndexes();
+ auto self = Toolkit::TextLabel::DownCast(Self());
- 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 self = Toolkit::TextLabel::DownCast(Self());
- auto slf = Toolkit::TextLabel::DownCast(Self());
- Dali::Toolkit::GetImpl(slf).getController()->SetSelection(0, 0);
- return true;
-}
-
-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
projects / platform / core / uifw / dali-toolkit.git / blobdiff