// EXTERNAL INCLUDES
#include <dali/devel-api/actors/actor-devel.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/adaptor-framework/adaptor.h>
DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "fontSizeScale", FLOAT, FONT_SIZE_SCALE )
DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "primaryCursorPosition", INTEGER, PRIMARY_CURSOR_POSITION )
DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "grabHandleColor", VECTOR4, GRAB_HANDLE_COLOR )
-
-DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "textChanged", SIGNAL_TEXT_CHANGED )
-DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "inputStyleChanged", SIGNAL_INPUT_STYLE_CHANGED)
-DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "maxLengthReached", SIGNAL_MAX_LENGTH_REACHED )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "enableGrabHandlePopup", BOOLEAN, ENABLE_GRAB_HANDLE_POPUP )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "inputMethodSettings", MAP, INPUT_METHOD_SETTINGS )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "inputFilter", MAP, INPUT_FILTER )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "ellipsis", BOOLEAN, ELLIPSIS )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "ellipsisPosition", INTEGER, ELLIPSIS_POSITION )
+DALI_DEVEL_PROPERTY_REGISTRATION(Toolkit, TextEditor, "minLineSize", FLOAT, MIN_LINE_SIZE )
+
+DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "textChanged", SIGNAL_TEXT_CHANGED )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "inputStyleChanged", SIGNAL_INPUT_STYLE_CHANGED )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "maxLengthReached", SIGNAL_MAX_LENGTH_REACHED )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "anchorClicked", SIGNAL_ANCHOR_CLICKED )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "inputFiltered", SIGNAL_INPUT_FILTERED )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "cursorPositionChanged", SIGNAL_CURSOR_POSITION_CHANGED)
+DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "selectionChanged", SIGNAL_SELECTION_CHANGED )
+DALI_SIGNAL_REGISTRATION(Toolkit, TextEditor, "selectionCleared", SIGNAL_SELECTION_CLEARED )
DALI_TYPE_REGISTRATION_END()
// clang-format on
}
case Toolkit::TextEditor::Property::LINE_SPACING:
{
- // The line spacing isn't supported by the TextEditor. Since it's supported
- // by the TextLabel for now it must be ignored. The property is being shadowed
- // locally so its value isn't affected.
const float lineSpacing = value.Get<float>();
- impl.mLineSpacing = lineSpacing;
- // set it to 0.0 due to missing implementation
- impl.mController->SetDefaultLineSpacing(0.0f);
+ impl.mController->SetDefaultLineSpacing(lineSpacing);
impl.mRenderer.Reset();
break;
}
}
case Toolkit::DevelTextEditor::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::DevelTextEditor::Property::MAX_LENGTH:
{
uint32_t position = static_cast<uint32_t>(value.Get<int>());
DALI_LOG_INFO(gLogFilter, Debug::General, "TextEditor %p PRIMARY_CURSOR_POSITION %d\n", impl.mController.Get(), position);
- if(impl.mController->SetPrimaryCursorPosition(position))
+ if(impl.mController->SetPrimaryCursorPosition(position, impl.HasKeyInputFocus()))
{
impl.SetKeyInputFocus();
}
impl.RequestTextRelayout();
break;
}
+ case Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE_POPUP:
+ {
+ const bool grabHandlePopupEnabled = value.Get<bool>();
+ DALI_LOG_INFO(gLogFilter, Debug::General, "TextEditor %p ENABLE_GRAB_HANDLE_POPUP %d\n", impl.mController.Get(), grabHandlePopupEnabled);
+
+ impl.mController->SetGrabHandlePopupEnabled(grabHandlePopupEnabled);
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::INPUT_METHOD_SETTINGS:
+ {
+ const Property::Map* map = value.GetMap();
+ if(map)
+ {
+ impl.mInputMethodOptions.ApplyProperty(*map);
+ }
+ impl.mController->SetInputModePassword(impl.mInputMethodOptions.IsPassword());
+
+ Toolkit::Control control = Toolkit::KeyInputFocusManager::Get().GetCurrentFocusControl();
+ if(control == textEditor)
+ {
+ impl.mInputMethodContext.ApplyOptions(impl.mInputMethodOptions);
+ }
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::INPUT_FILTER:
+ {
+ const Property::Map* map = value.GetMap();
+ if(map)
+ {
+ impl.mController->SetInputFilterOption(*map);
+ }
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::ELLIPSIS:
+ {
+ const bool ellipsis = value.Get<bool>();
+ DALI_LOG_INFO(gLogFilter, Debug::General, "TextEditor %p ELLIPSIS %d\n", impl.mController.Get(), ellipsis);
+
+ impl.mController->SetTextElideEnabled(ellipsis);
+ break;
+ }
+ case Toolkit::DevelTextEditor::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, "TextEditor %p EllipsisPosition::Type %d\n", impl.mController.Get(), ellipsisPositionType);
+ impl.mController->SetEllipsisPosition(ellipsisPositionType);
+ }
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::MIN_LINE_SIZE:
+ {
+ const float minLineSize = value.Get<float>();
+ DALI_LOG_INFO(gLogFilter, Debug::Verbose, "TextEditor %p MIN_LINE_SIZE %f\n", impl.mController.Get(), minLineSize);
+
+ impl.mController->SetDefaultLineSize(minLineSize);
+ impl.mRenderer.Reset();
+ break;
+ }
} // switch
} // texteditor
}
}
case Toolkit::TextEditor::Property::LINE_SPACING:
{
- // LINE_SPACING isn't implemented for the TextEditor. Returning
- // only shadowed value, not the real one.
- value = impl.mLineSpacing;
+ value = impl.mController->GetDefaultLineSpacing();
break;
}
case Toolkit::TextEditor::Property::INPUT_LINE_SPACING:
}
case Toolkit::DevelTextEditor::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION:
{
- value = impl.mController->IsMatchSystemLanguageDirection();
+ value = impl.mController->GetMatchLayoutDirection() != DevelText::MatchLayoutDirection::CONTENTS;
break;
}
case Toolkit::DevelTextEditor::Property::MAX_LENGTH:
value = impl.mDecorator->GetHandleColor();
break;
}
+ case Toolkit::DevelTextEditor::Property::ENABLE_GRAB_HANDLE_POPUP:
+ {
+ value = impl.mController->IsGrabHandlePopupEnabled();
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::INPUT_METHOD_SETTINGS:
+ {
+ Property::Map map;
+ impl.mInputMethodOptions.RetrieveProperty(map);
+ value = map;
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::INPUT_FILTER:
+ {
+ Property::Map map;
+ impl.mController->GetInputFilterOption(map);
+ value = map;
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::ELLIPSIS:
+ {
+ value = impl.mController->IsTextElideEnabled();
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::ELLIPSIS_POSITION:
+ {
+ value = impl.mController->GetEllipsisPosition();
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::MIN_LINE_SIZE:
+ {
+ value = impl.mController->GetDefaultLineSize();
+ break;
+ }
} //switch
}
}
}
+void TextEditor::SelectText(const uint32_t start, const uint32_t end)
+{
+ if(mController && mController->IsShowingRealText())
+ {
+ mController->SelectText(start, end);
+ SetKeyInputFocus();
+ }
+}
+
+string TextEditor::CopyText()
+{
+ string copiedText = "";
+ if(mController && mController->IsShowingRealText())
+ {
+ copiedText = mController->CopyText();
+ }
+ return copiedText;
+}
+
+string TextEditor::CutText()
+{
+ string cutText = "";
+ if(mController && mController->IsShowingRealText())
+ {
+ cutText = mController->CutText();
+ }
+ return cutText;
+}
+
+void TextEditor::PasteText()
+{
+ if(mController)
+ {
+ SetKeyInputFocus(); //Giving focus to the editor that was passed to the PasteText in case the passed editor (current editor) doesn't have focus.
+ mController->PasteText();
+ }
+}
+
void TextEditor::ScrollBy(Vector2 scroll)
{
if(mController && mController->IsShowingRealText())
return mMaxLengthReachedSignal;
}
-Text::ControllerPtr TextEditor::getController()
+DevelTextEditor::AnchorClickedSignalType& TextEditor::AnchorClickedSignal()
+{
+ return mAnchorClickedSignal;
+}
+
+DevelTextEditor::CursorPositionChangedSignalType& TextEditor::CursorPositionChangedSignal()
+{
+ return mCursorPositionChangedSignal;
+}
+
+DevelTextEditor::InputFilteredSignalType& TextEditor::InputFilteredSignal()
+{
+ return mInputFilteredSignal;
+}
+
+DevelTextEditor::SelectionChangedSignalType& TextEditor::SelectionChangedSignal()
+{
+ return mSelectionChangedSignal;
+}
+
+DevelTextEditor::SelectionClearedSignalType& TextEditor::SelectionClearedSignal()
+{
+ return mSelectionClearedSignal;
+}
+
+Text::ControllerPtr TextEditor::GetTextController()
{
return mController;
}
editorImpl.MaxLengthReachedSignal().Connect(tracker, functor);
}
}
+ else if(0 == strcmp(signalName.c_str(), SIGNAL_ANCHOR_CLICKED))
+ {
+ if(editor)
+ {
+ Internal::TextEditor& editorImpl(GetImpl(editor));
+ editorImpl.AnchorClickedSignal().Connect(tracker, functor);
+ }
+ }
+ else if(0 == strcmp(signalName.c_str(), SIGNAL_CURSOR_POSITION_CHANGED))
+ {
+ if(editor)
+ {
+ Internal::TextEditor& editorImpl(GetImpl(editor));
+ editorImpl.CursorPositionChangedSignal().Connect(tracker, functor);
+ }
+ }
+ else if(0 == strcmp(signalName.c_str(), SIGNAL_INPUT_FILTERED))
+ {
+ if(editor)
+ {
+ Internal::TextEditor& editorImpl(GetImpl(editor));
+ editorImpl.InputFilteredSignal().Connect(tracker, functor);
+ }
+ }
+ else if(0 == strcmp(signalName.c_str(), SIGNAL_SELECTION_CHANGED))
+ {
+ if(editor)
+ {
+ Internal::TextEditor& editorImpl(GetImpl(editor));
+ editorImpl.SelectionChangedSignal().Connect(tracker, functor);
+ }
+ }
+ else if(0 == strcmp(signalName.c_str(), SIGNAL_SELECTION_CLEARED))
+ {
+ if(editor)
+ {
+ Internal::TextEditor& editorImpl(GetImpl(editor));
+ editorImpl.SelectionClearedSignal().Connect(tracker, functor);
+ }
+ }
else
{
// signalName does not match any signal
{
Actor self = Self();
- mController = Text::Controller::New(this, this, this);
+ mController = Text::Controller::New(this, this, this, this);
mDecorator = Text::Decorator::New(*mController,
*mController);
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, &TextEditor::OnLayoutDirectionChanged);
+
// Forward input events to controller
EnableGestureDetection(static_cast<GestureType::Value>(GestureType::TAP | GestureType::PAN | GestureType::LONG_PRESS));
GetTapGestureDetector().SetMaximumTapsRequired(2);
+ GetTapGestureDetector().ReceiveAllTapEvents(true);
self.TouchedSignal().Connect(this, &TextEditor::OnTouched);
Vector2 contentSize(size.x - (padding.start + padding.end), size.y - (padding.top + padding.bottom));
// Support Right-To-Left of padding
- 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);
+
if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
{
std::swap(padding.start, padding.end);
ResizeActor(mActiveLayer, contentSize);
}
+ // If there is text changed, callback is called.
+ if(mTextChanged)
+ {
+ EmitTextChangedSignal();
+ }
+
const Text::Controller::UpdateTextType updateTextType = mController->Relayout(contentSize, layoutDirection);
if((Text::Controller::NONE_UPDATED != updateTextType) ||
}
RenderText(updateTextType);
+ }
- // If there is text changed, callback is called.
- if(mTextChanged)
- {
- Dali::Toolkit::TextEditor handle(GetOwner());
- mTextChangedSignal.Emit(handle);
- mTextChanged = false;
- }
+ if(mCursorPositionChanged)
+ {
+ EmitCursorPositionChangedSignal();
+ }
+
+ if(mSelectionChanged)
+ {
+ EmitSelectionChangedSignal();
+ }
+
+ if(mSelectionCleared)
+ {
+ EmitSelectionClearedSignal();
}
// The text-editor emits signals when the input style changes. These changes of style are
if(renderableActor != mRenderableActor)
{
+ UnparentAndReset(mBackgroundActor);
UnparentAndReset(mRenderableActor);
mRenderableActor = renderableActor;
+
+ if(mRenderableActor)
+ {
+ mBackgroundActor = mController->CreateBackgroundActor();
+ }
}
}
if(mRenderableActor)
{
+ const Vector2& scrollOffset = mController->GetTextModel()->GetScrollPosition();
+
+ float renderableActorPositionX, renderableActorPositionY;
+
+ if(mStencil)
+ {
+ renderableActorPositionX = scrollOffset.x + mAlignmentOffset;
+ renderableActorPositionY = scrollOffset.y;
+ }
+ else
+ {
+ Extents padding;
+ padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
+
+ // Support Right-To-Left of padding
+ Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>(Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>());
+ if(Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection)
+ {
+ std::swap(padding.start, padding.end);
+ }
+
+ renderableActorPositionX = scrollOffset.x + mAlignmentOffset + padding.start;
+ renderableActorPositionY = scrollOffset.y + padding.top;
+ }
+
+ mRenderableActor.SetProperty(Actor::Property::POSITION, Vector2(renderableActorPositionX, renderableActorPositionY));
// Make sure the actors are parented correctly with/without clipping
Actor self = mStencil ? mStencil : Self();
+ Actor highlightActor;
+
for(std::vector<Actor>::iterator it = mClippingDecorationActors.begin(),
endIt = mClippingDecorationActors.end();
it != endIt;
{
self.Add(*it);
it->LowerToBottom();
+
+ if(it->GetProperty<std::string>(Dali::Actor::Property::NAME) == "HighlightActor")
+ {
+ highlightActor = *it;
+ }
}
mClippingDecorationActors.clear();
self.Add(mRenderableActor);
+ if(mBackgroundActor)
+ {
+ if(mDecorator && mDecorator->IsHighlightVisible())
+ {
+ self.Add(mBackgroundActor);
+ mBackgroundActor.SetProperty(Actor::Property::POSITION, Vector2(renderableActorPositionX, renderableActorPositionY)); // In text field's coords.
+ mBackgroundActor.LowerBelow(highlightActor);
+ }
+ else
+ {
+ mRenderableActor.Add(mBackgroundActor);
+ mBackgroundActor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f)); // In renderable actor's coords.
+ mBackgroundActor.LowerToBottom();
+ }
+ }
+
ApplyScrollPosition();
}
UpdateScrollBar();
if(mInputMethodContext && IsEditable())
{
// All input panel properties, such as layout, return key type, and input hint, should be set before input panel activates (or shows).
+ mInputMethodContext.ApplyOptions(mInputMethodOptions);
mInputMethodContext.NotifyTextInputMultiLine(true);
mInputMethodContext.StatusChangedSignal().Connect(this, &TextEditor::KeyboardStatusChanged);
padding = Self().GetProperty<Extents>(Toolkit::Control::Property::PADDING);
const Vector2& localPoint = gesture.GetLocalPoint();
mController->TapEvent(gesture.GetNumberOfTaps(), localPoint.x - padding.start, localPoint.y - padding.top);
+ mController->AnchorEvent(localPoint.x - padding.start, localPoint.y - padding.top);
SetKeyInputFocus();
}
}
}
-void TextEditor::CaretMoved(unsigned int position)
+void TextEditor::CursorPositionChanged(unsigned int oldPosition, unsigned int newPosition)
{
if(Accessibility::IsUp())
{
- Control::Impl::GetAccessibilityObject(Self())->EmitTextCaretMoved(position);
+ Control::Impl::GetAccessibilityObject(Self())->EmitTextCursorMoved(newPosition);
+ }
+
+ if((oldPosition != newPosition) && !mCursorPositionChanged)
+ {
+ mCursorPositionChanged = true;
+ mOldPosition = oldPosition;
+ }
+}
+
+void TextEditor::TextChanged(bool immediate)
+{
+ if(immediate) // Emits TextChangedSignal immediately
+ {
+ EmitTextChangedSignal();
+ }
+ else
+ {
+ mTextChanged = true;
}
}
-void TextEditor::TextChanged()
+void TextEditor::EmitTextChangedSignal()
{
- mTextChanged = true;
+ Dali::Toolkit::TextEditor handle(GetOwner());
+ mTextChangedSignal.Emit(handle);
+ mTextChanged = false;
}
void TextEditor::MaxLengthReached()
mInputStyleChangedSignal.Emit(handle, editorInputStyleMask);
}
+void TextEditor::AnchorClicked(const std::string& href)
+{
+ Dali::Toolkit::TextEditor handle(GetOwner());
+ mAnchorClickedSignal.Emit(handle, href.c_str(), href.length());
+}
+
+void TextEditor::EmitCursorPositionChangedSignal()
+{
+ Dali::Toolkit::TextEditor handle(GetOwner());
+ mCursorPositionChanged = false;
+ mCursorPositionChangedSignal.Emit(handle, mOldPosition);
+}
+
+void TextEditor::InputFiltered(Toolkit::InputFilter::Property::Type type)
+{
+ Dali::Toolkit::TextEditor handle(GetOwner());
+ mInputFilteredSignal.Emit(handle, type);
+}
+
+void TextEditor::EmitSelectionChangedSignal()
+{
+ Dali::Toolkit::TextEditor handle(GetOwner());
+ mSelectionChangedSignal.Emit(handle, mOldSelectionStart, mOldSelectionEnd);
+ mSelectionChanged = false;
+}
+
+void TextEditor::EmitSelectionClearedSignal()
+{
+ Dali::Toolkit::TextEditor handle(GetOwner());
+ mSelectionClearedSignal.Emit(handle);
+ mSelectionCleared = false;
+}
+
+void TextEditor::SelectionChanged(uint32_t oldStart, uint32_t oldEnd, uint32_t newStart, uint32_t newEnd)
+{
+ if(((oldStart != newStart) || (oldEnd != newEnd)) && !mSelectionChanged)
+ {
+ if(newStart == newEnd)
+ {
+ mSelectionCleared = true;
+ }
+
+ mSelectionChanged = true;
+ mOldSelectionStart = oldStart;
+ mOldSelectionEnd = oldEnd;
+
+ if(mOldSelectionStart > mOldSelectionEnd)
+ {
+ //swap
+ uint32_t temp = mOldSelectionStart;
+ mOldSelectionStart = mOldSelectionEnd;
+ mOldSelectionEnd = temp;
+ }
+ }
+}
+
void TextEditor::AddDecoration(Actor& actor, bool needsClipping)
{
if(actor)
return range;
}
+void TextEditor::GetControlBackgroundColor(Vector4& color) const
+{
+ Property::Value propValue = Self().GetProperty(Toolkit::Control::Property::BACKGROUND);
+ Property::Map* resultMap = propValue.GetMap();
+
+ Property::Value* colorValue = nullptr;
+ if(resultMap && (colorValue = resultMap->Find(ColorVisual::Property::MIX_COLOR)))
+ {
+ colorValue->Get(color);
+ }
+}
+
void TextEditor::UpdateScrollBar()
{
using namespace Dali;
}
}
+void TextEditor::OnLayoutDirectionChanged(Actor actor, LayoutDirection::Type type)
+{
+ mController->ChangedLayoutDirection();
+}
+
TextEditor::TextEditor()
: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
mAnimationPeriod(0.0f, 0.0f),
mScrollAnimationEnabled(false),
mScrollBarEnabled(false),
mScrollStarted(false),
- mTextChanged(false)
+ mTextChanged(false),
+ mCursorPositionChanged(false),
+ mSelectionChanged(false),
+ mSelectionCleared(false),
+ mOldPosition(0u),
+ mOldSelectionStart(0u),
+ mOldSelectionEnd(0u)
{
}
std::string TextEditor::AccessibleImpl::GetName()
{
- auto slf = Toolkit::TextEditor::DownCast(self);
- return slf.GetProperty(Toolkit::TextEditor::Property::TEXT)
- .Get<std::string>();
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ return self.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
}
-std::string TextEditor::AccessibleImpl::GetText(size_t startOffset,
- size_t endOffset)
+std::string TextEditor::AccessibleImpl::GetText(size_t startOffset, size_t endOffset)
{
if(endOffset <= startOffset)
+ {
return {};
+ }
- auto slf = Toolkit::TextEditor::DownCast(self);
- auto txt =
- slf.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ auto text = self.GetProperty(Toolkit::TextEditor::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 TextEditor::AccessibleImpl::GetCharacterCount()
{
- auto slf = Toolkit::TextEditor::DownCast(self);
- auto txt =
- slf.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ auto text = self.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
- return txt.size();
+ return text.size();
}
-size_t TextEditor::AccessibleImpl::GetCaretOffset()
+size_t TextEditor::AccessibleImpl::GetCursorOffset()
{
- auto slf = Toolkit::TextEditor::DownCast(self);
- return Dali::Toolkit::GetImpl(slf).getController()->GetCursorPosition();
+ auto slf = Toolkit::TextEditor::DownCast(Self());
+ return Dali::Toolkit::GetImpl(slf).GetTextController()->GetCursorPosition();
}
-bool TextEditor::AccessibleImpl::SetCaretOffset(size_t offset)
+bool TextEditor::AccessibleImpl::SetCursorOffset(size_t offset)
{
- auto slf = Toolkit::TextEditor::DownCast(self);
+ auto slf = Toolkit::TextEditor::DownCast(Self());
auto txt = slf.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
if(offset > txt.size())
+ {
return false;
+ }
auto& slfImpl = Dali::Toolkit::GetImpl(slf);
- slfImpl.getController()->ResetCursorPosition(offset);
+ slfImpl.GetTextController()->ResetCursorPosition(offset);
slfImpl.RequestTextRelayout();
+
return true;
}
-Dali::Accessibility::Range TextEditor::AccessibleImpl::GetTextAtOffset(
- size_t offset, Dali::Accessibility::TextBoundary boundary)
+Dali::Accessibility::Range TextEditor::AccessibleImpl::GetTextAtOffset(size_t offset, Dali::Accessibility::TextBoundary boundary)
{
- auto slf = Toolkit::TextEditor::DownCast(self);
- auto txt = slf.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
- auto txt_size = txt.size();
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ auto text = self.GetProperty(Toolkit::TextEditor::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());
+ {
+ 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
-TextEditor::AccessibleImpl::GetSelection(size_t selectionNum)
+Dali::Accessibility::Range TextEditor::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::TextEditor::DownCast(self);
- auto ctrl = Dali::Toolkit::GetImpl(slf).getController();
- std::string ret;
- ctrl->RetrieveSelection(ret);
- auto r = ctrl->GetSelectionIndexes();
+ auto self = Toolkit::TextEditor::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 TextEditor::AccessibleImpl::RemoveSelection(size_t selectionNum)
+bool TextEditor::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::TextEditor::DownCast(self);
- Dali::Toolkit::GetImpl(slf).getController()->SetSelection(0, 0);
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(0, 0);
return true;
}
-bool TextEditor::AccessibleImpl::SetSelection(size_t selectionNum,
- size_t startOffset,
- size_t endOffset)
+bool TextEditor::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::TextEditor::DownCast(self);
- Dali::Toolkit::GetImpl(slf).getController()->SetSelection(startOffset,
- endOffset);
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ Dali::Toolkit::GetImpl(self).GetTextController()->SetSelection(startOffset, endOffset);
return true;
}
-bool TextEditor::AccessibleImpl::CopyText(size_t startPosition,
- size_t endPosition)
+bool TextEditor::AccessibleImpl::CopyText(size_t startPosition, size_t endPosition)
{
if(endPosition <= startPosition)
+ {
return false;
+ }
- auto slf = Toolkit::TextEditor::DownCast(self);
- auto txt = slf.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
- Dali::Toolkit::GetImpl(slf).getController()->CopyStringToClipboard(txt.substr(startPosition, endPosition - startPosition));
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ auto text = self.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
+ Dali::Toolkit::GetImpl(self).GetTextController()->CopyStringToClipboard(text.substr(startPosition, endPosition - startPosition));
return true;
}
-bool TextEditor::AccessibleImpl::CutText(size_t startPosition,
- size_t endPosition)
+bool TextEditor::AccessibleImpl::CutText(size_t startPosition, size_t endPosition)
{
if(endPosition <= startPosition)
+ {
return false;
+ }
- auto slf = Toolkit::TextEditor::DownCast(self);
- auto txt = slf.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
- Dali::Toolkit::GetImpl(slf).getController()->CopyStringToClipboard(txt.substr(startPosition, endPosition - startPosition));
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ auto text = self.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
+ Dali::Toolkit::GetImpl(self).GetTextController()->CopyStringToClipboard(text.substr(startPosition, endPosition - startPosition));
- slf.SetProperty(Toolkit::TextEditor::Property::TEXT,
- txt.substr(0, startPosition) + txt.substr(endPosition - startPosition, txt.size()));
+ self.SetProperty(Toolkit::TextEditor::Property::TEXT, text.substr(0, startPosition) + text.substr(endPosition));
+
+ return true;
+}
+
+bool TextEditor::AccessibleImpl::DeleteText(size_t startPosition, size_t endPosition)
+{
+ if(endPosition <= startPosition)
+ {
+ return false;
+ }
+
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ auto text = self.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
+
+ self.SetProperty(Toolkit::TextEditor::Property::TEXT, text.substr(0, startPosition) + text.substr(endPosition));
return true;
}
states[State::FOCUSABLE] = true;
Toolkit::Control focusControl = Toolkit::KeyInputFocusManager::Get().GetCurrentFocusControl();
- if(self == focusControl)
+ if(mSelf == focusControl)
{
states[State::FOCUSED] = true;
}
return states;
}
+bool TextEditor::AccessibleImpl::InsertText(size_t startPosition, std::string text)
+{
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ auto insertedText = self.GetProperty(Toolkit::TextEditor::Property::TEXT).Get<std::string>();
+
+ insertedText.insert(startPosition, text);
+
+ self.SetProperty(Toolkit::TextEditor::Property::TEXT, std::move(insertedText));
+
+ return true;
+}
+
+bool TextEditor::AccessibleImpl::SetTextContents(std::string newContents)
+{
+ auto self = Toolkit::TextEditor::DownCast(Self());
+ self.SetProperty(Toolkit::TextEditor::Property::TEXT, std::move(newContents));
+ return true;
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff