#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>
#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;
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, "ellipsisPosition", INTEGER, ELLIPSIS_POSITION )
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_TYPE_REGISTRATION_END()
// clang-format on
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:
}
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;
+ }
}
// 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:
value = impl.mController->GetFontSizeScale();
break;
}
+ case Toolkit::DevelTextLabel::Property::ELLIPSIS_POSITION:
+ {
+ value = impl.mController->GetEllipsisPosition();
+ 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
+ {
+ // signalName does not match any signal
+ connected = false;
+ }
+
+ return connected;
+}
+
+DevelTextLabel::AnchorClickedSignalType& TextLabel::AnchorClickedSignal()
+{
+ return mAnchorClickedSignal;
+}
+
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);
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.
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;
{
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)
RequestTextRelayout();
}
+void TextLabel::OnLayoutDirectionChanged(Actor actor, LayoutDirection::Type type)
+{
+ mController->ChangedLayoutDirection();
+}
+
TextLabel::TextLabel()
: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
mRenderingBackend(DEFAULT_RENDERING_BACKEND),
std::string TextLabel::AccessibleImpl::GetNameRaw()
{
- auto slf = Toolkit::TextLabel::DownCast(self);
- return slf.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
+ auto self = Toolkit::TextLabel::DownCast(Self());
+ return self.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
}
Property::Index TextLabel::AccessibleImpl::GetNamePropertyIndex()
return Toolkit::TextLabel::Property::TEXT;
}
-std::string TextLabel::AccessibleImpl::GetText(size_t startOffset,
- size_t endOffset)
+std::string TextLabel::AccessibleImpl::GetText(size_t startOffset, size_t endOffset)
{
if(endOffset <= startOffset)
+ {
return {};
+ }
- auto slf = Toolkit::TextLabel::DownCast(self);
- auto txt =
- slf.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
+ auto self = Toolkit::TextLabel::DownCast(Self());
+ auto text = self.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
- if(startOffset > txt.size() || endOffset > txt.size())
+ if(startOffset > text.size() || endOffset > text.size())
+ {
return {};
+ }
- return txt.substr(startOffset, endOffset - startOffset);
+ return text.substr(startOffset, endOffset - startOffset);
}
size_t TextLabel::AccessibleImpl::GetCharacterCount()
{
- auto slf = Toolkit::TextLabel::DownCast(self);
- auto txt =
- slf.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
+ auto self = Toolkit::TextLabel::DownCast(Self());
+ auto text = self.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
- return txt.size();
+ return text.size();
}
-size_t TextLabel::AccessibleImpl::GetCaretOffset()
+size_t TextLabel::AccessibleImpl::GetCursorOffset()
{
return {};
}
-bool TextLabel::AccessibleImpl::SetCaretOffset(size_t offset)
+bool TextLabel::AccessibleImpl::SetCursorOffset(size_t offset)
{
return {};
}
-Dali::Accessibility::Range TextLabel::AccessibleImpl::GetTextAtOffset(
- size_t offset, Dali::Accessibility::TextBoundary boundary)
+Dali::Accessibility::Range TextLabel::AccessibleImpl::GetTextAtOffset(size_t offset, Dali::Accessibility::TextBoundary boundary)
{
- auto slf = Toolkit::TextLabel::DownCast(self);
- auto txt = slf.GetProperty(Toolkit::TextLabel::Property::TEXT).Get<std::string>();
- auto txt_size = txt.size();
+ 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{};
{
case Dali::Accessibility::TextBoundary::CHARACTER:
{
- if(offset < txt_size)
+ if(offset < textSize)
{
- range.content = txt[offset];
+ range.content = text[offset];
range.startOffset = offset;
range.endOffset = offset + 1;
}
+ break;
}
- 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);
+ auto textString = text.c_str();
+ auto breaks = std::vector<char>(textSize, 0);
+
if(boundary == Dali::Accessibility::TextBoundary::WORD)
- Accessibility::Accessible::FindWordSeparationsUtf8((const utf8_t*)txt_c_string, txt_size, "", breaks.data());
+ {
+ Accessibility::Accessible::FindWordSeparationsUtf8(reinterpret_cast<const utf8_t*>(textString), textSize, "", breaks.data());
+ }
else
- Accessibility::Accessible::FindLineSeparationsUtf8((const utf8_t*)txt_c_string, txt_size, "", breaks.data());
- auto index = 0u;
+ {
+ Accessibility::Accessible::FindLineSeparationsUtf8(reinterpret_cast<const utf8_t*>(textString), textSize, "", breaks.data());
+ }
+
+ auto index = 0u;
auto counter = 0u;
- while(index < txt_size && counter <= offset)
+ 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 = txt.substr(start, index - start + 1);
+ range.content = text.substr(start, index - start + 1);
range.startOffset = start;
range.endOffset = index + 1;
}
+
if(boundary == Dali::Accessibility::TextBoundary::LINE)
+ {
index++;
+ }
}
+ break;
}
- break;
case Dali::Accessibility::TextBoundary::SENTENCE:
{
- /* not supported by efl */
+ /* not supported by default */
+ break;
}
- break;
case Dali::Accessibility::TextBoundary::PARAGRAPH:
{
/* Paragraph is not supported by libunibreak library */
+ break;
}
- break;
default:
break;
}
return range;
}
-Dali::Accessibility::Range
-TextLabel::AccessibleImpl::GetSelection(size_t selectionNum)
+Dali::Accessibility::Range TextLabel::AccessibleImpl::GetRangeOfSelection(size_t selectionIndex)
{
// Since DALi supports only one selection indexes higher than 0 are ignored
- if(selectionNum > 0)
+ if(selectionIndex > 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());
+ auto controller = Dali::Toolkit::GetImpl(self).GetTextController();
+ std::string value{};
+ controller->RetrieveSelection(value);
+ auto indices = controller->GetSelectionIndexes();
- return {static_cast<size_t>(r.first), static_cast<size_t>(r.second), ret};
+ return {static_cast<size_t>(indices.first), static_cast<size_t>(indices.second), value};
}
-bool TextLabel::AccessibleImpl::RemoveSelection(size_t selectionNum)
+bool TextLabel::AccessibleImpl::RemoveSelection(size_t selectionIndex)
{
// Since DALi supports only one selection indexes higher than 0 are ignored
- if(selectionNum > 0)
+ if(selectionIndex > 0)
+ {
return false;
+ }
- auto slf = Toolkit::TextLabel::DownCast(self);
- Dali::Toolkit::GetImpl(slf).getController()->SetSelection(0, 0);
+ auto self = Toolkit::TextLabel::DownCast(Self());
+ Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(0, 0);
return true;
}
-bool TextLabel::AccessibleImpl::SetSelection(size_t selectionNum,
- size_t startOffset,
- size_t endOffset)
+bool TextLabel::AccessibleImpl::SetRangeOfSelection(size_t selectionIndex, size_t startOffset, size_t endOffset)
{
// Since DALi supports only one selection indexes higher than 0 are ignored
- if(selectionNum > 0)
+ if(selectionIndex > 0)
+ {
return false;
+ }
- auto slf = Toolkit::TextLabel::DownCast(self);
- Dali::Toolkit::GetImpl(slf).getController()->SetSelection(startOffset,
- endOffset);
+ auto self = Toolkit::TextLabel::DownCast(Self());
+ Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(startOffset, endOffset);
return true;
}
projects / platform / core / uifw / dali-toolkit.git / blobdiff