/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 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.
// EXTERNAL INCLUDES
#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
#include <dali/devel-api/adaptor-framework/window-devel.h>
+#include <dali/integration-api/adaptor-framework/adaptor.h>
#include <dali/integration-api/debug.h>
#include <memory.h>
#include <cmath>
Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
#endif
-const std::string EMPTY_STRING("");
+const char* EMPTY_STRING = "";
+const char* MIME_TYPE_TEXT_PLAIN = "text/plain;charset=utf-8";
+const char* MIME_TYPE_HTML = "application/xhtml+xml";
template<typename Type>
void EnsureCreated(Type*& object)
float GetDpi()
{
- unsigned int horizontalDpi = 0u;
- unsigned int verticalDpi = 0u;
- Dali::TextAbstraction::FontClient fontClient = Dali::TextAbstraction::FontClient::Get();
- fontClient.GetDpi(horizontalDpi, verticalDpi);
+ static uint32_t horizontalDpi = 0u;
+ static uint32_t verticalDpi = 0u;
+
+ // TODO : How can we know when fontClient DPI changed case?
+ if(DALI_UNLIKELY(horizontalDpi == 0u))
+ {
+ Dali::TextAbstraction::FontClient fontClient = Dali::TextAbstraction::FontClient::Get();
+ fontClient.GetDpi(horizontalDpi, verticalDpi);
+ }
return static_cast<float>(horizontalDpi);
}
mImpl->mModel->mIgnoreSpacesAfterText = ignore;
}
+bool Controller::IsRemoveFrontInset() const
+{
+ return mImpl->mModel->mRemoveFrontInset;
+}
+
+void Controller::SetRemoveFrontInset(bool remove)
+{
+ mImpl->mModel->mRemoveFrontInset = remove;
+}
+
+bool Controller::IsRemoveBackInset() const
+{
+ return mImpl->mModel->mRemoveBackInset;
+}
+
+void Controller::SetRemoveBackInset(bool remove)
+{
+ mImpl->mModel->mRemoveBackInset = remove;
+}
+
+bool Controller::IsTextCutout() const
+{
+ return mImpl->mTextCutout;
+}
+
+void Controller::SetTextCutout(bool cutout)
+{
+ if(cutout != mImpl->mTextCutout)
+ {
+ mImpl->mModel->mVisualModel->SetCutoutEnabled(cutout);
+ mImpl->mTextCutout = cutout;
+ mImpl->RequestRelayout();
+ }
+}
+
void Controller::ChangedLayoutDirection()
{
mImpl->mIsLayoutDirectionChanged = true;
}
+void Controller::ResetFontAndStyleData()
+{
+ mImpl->ResetFontAndStyleData();
+}
+
void Controller::SetMatchLayoutDirection(DevelText::MatchLayoutDirection type)
{
mImpl->mModel->mMatchLayoutDirection = type;
return mImpl->mTextFitChanged;
}
+void Controller::SetCurrentLineSize(float lineSize)
+{
+ mImpl->mCurrentLineSize = lineSize;
+}
+
+float Controller::GetCurrentLineSize() const
+{
+ return mImpl->mCurrentLineSize;
+}
+
void Controller::SetTextFitMinSize(float minSize, FontSizeType type)
{
mImpl->mTextFitMinSize = (type == POINT_SIZE) ? minSize : ConvertPixelToPoint(minSize);
return mImpl->mFontDefaults ? mImpl->mFontDefaults->mFitPointSize : 0.0f;
}
+void Controller::SetTextFitLineSize(float lineSize)
+{
+ mImpl->mTextFitLineSize = lineSize;
+}
+
+void Controller::SetTextFitArrayEnabled(bool enabled)
+{
+ mImpl->mTextFitArrayEnabled = enabled;
+ mImpl->ClearFontData();
+ mImpl->RequestRelayout();
+}
+
+bool Controller::IsTextFitArrayEnabled() const
+{
+ return mImpl->mTextFitArrayEnabled;
+}
+
+void Controller::SetTextFitArray(std::vector<Toolkit::DevelTextLabel::FitOption>& fitOptions)
+{
+ mImpl->mTextFitArray = fitOptions;
+}
+
+std::vector<Toolkit::DevelTextLabel::FitOption>& Controller::GetTextFitArray()
+{
+ return mImpl->mTextFitArray;
+}
+
void Controller::SetPlaceholderTextElideEnabled(bool enabled)
{
PlaceholderHandler::SetPlaceholderTextElideEnabled(*this, enabled);
mImpl->GetText(text);
}
+Length Controller::GetNumberOfCharacters() const
+{
+ return mImpl->GetNumberOfCharacters();
+}
+
void Controller::SetSpannedText(const Text::Spanned& spannedText)
{
SpannableHandler::SetSpannedText(*this, spannedText);
{
EnsureCreated(mImpl->mFontDefaults);
- mImpl->mFontDefaults->mFontDescription.family = defaultFontFamily;
- DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetDefaultFontFamily %s\n", defaultFontFamily.c_str());
- mImpl->mFontDefaults->familyDefined = !defaultFontFamily.empty();
+ if(mImpl->mFontDefaults->mFontDescription.family != defaultFontFamily)
+ {
+ mImpl->mFontDefaults->mFontDescription.family = defaultFontFamily;
+ DALI_LOG_INFO(gLogFilter, Debug::General, "Controller::SetDefaultFontFamily %s\n", defaultFontFamily.c_str());
+ mImpl->mFontDefaults->familyDefined = !defaultFontFamily.empty();
- // Update the cursor position if it's in editing mode
- UpdateCursorPosition(mImpl->mEventData);
+ // Update the cursor position if it's in editing mode
+ UpdateCursorPosition(mImpl->mEventData);
- // Clear the font-specific data
- mImpl->ClearFontData();
+ // Clear the font-specific data
+ mImpl->ClearFontData();
- mImpl->RequestRelayout();
+ mImpl->RequestRelayout();
+ }
}
-const std::string& Controller::GetDefaultFontFamily() const
+std::string Controller::GetDefaultFontFamily() const
{
return mImpl->mFontDefaults ? mImpl->mFontDefaults->mFontDescription.family : EMPTY_STRING;
}
PlaceholderHandler::SetPlaceholderFontFamily(*this, placeholderTextFontFamily);
}
-const std::string& Controller::GetPlaceholderFontFamily() const
+std::string Controller::GetPlaceholderFontFamily() const
{
return PlaceholderHandler::GetPlaceholderFontFamily(*this);
}
mImpl->ClearFontData();
mImpl->RequestRelayout();
+
+ if(mImpl->mEventData && EventData::INACTIVE != mImpl->mEventData->mState)
+ {
+ SetInputFontPointSize(fontSize, true);
+ }
}
float Controller::GetDefaultFontSize(FontSizeType type) const
return mImpl->mTextColor;
}
+void Controller::SetAnchorColor(const Vector4& color)
+{
+ mImpl->SetAnchorColor(color);
+}
+
+const Vector4& Controller::GetAnchorColor() const
+{
+ return mImpl->GetAnchorColor();
+}
+
+void Controller::SetAnchorClickedColor(const Vector4& color)
+{
+ mImpl->SetAnchorClickedColor(color);
+}
+
+const Vector4& Controller::GetAnchorClickedColor() const
+{
+ return mImpl->GetAnchorClickedColor();
+}
+
void Controller::SetDisabledColorOpacity(float opacity)
{
mImpl->mDisabledColorOpacity = opacity;
return mImpl->mModel->mVisualModel->GetDashedUnderlineGap();
}
+void Controller::SetOutlineOffset(const Vector2& outlineOffset)
+{
+ mImpl->mModel->mVisualModel->SetOutlineOffset(outlineOffset);
+ mImpl->RequestRelayout();
+}
+
+const Vector2& Controller::GetOutlineOffset() const
+{
+ return mImpl->mModel->mVisualModel->GetOutlineOffset();
+}
+
void Controller::SetOutlineColor(const Vector4& color)
{
mImpl->mModel->mVisualModel->SetOutlineColor(color);
return mImpl->mModel->mVisualModel->GetOutlineWidth();
}
+void Controller::SetOutlineBlurRadius(const float& outlineBlurRadius)
+{
+ if(fabsf(GetOutlineBlurRadius() - outlineBlurRadius) > Math::MACHINE_EPSILON_1)
+ {
+ mImpl->mModel->mVisualModel->SetOutlineBlurRadius(outlineBlurRadius);
+ mImpl->RequestRelayout();
+ }
+}
+
+const float& Controller::GetOutlineBlurRadius() const
+{
+ return mImpl->mModel->mVisualModel->GetOutlineBlurRadius();
+}
+
void Controller::SetBackgroundColor(const Vector4& color)
{
mImpl->mModel->mVisualModel->SetBackgroundColor(color);
mImpl->mEmbossDefaults->properties = embossProperties;
}
-const std::string& Controller::GetDefaultEmbossProperties() const
+std::string Controller::GetDefaultEmbossProperties() const
{
return mImpl->mEmbossDefaults ? mImpl->mEmbossDefaults->properties : EMPTY_STRING;
}
mImpl->mOutlineDefaults->properties = outlineProperties;
}
-const std::string& Controller::GetDefaultOutlineProperties() const
+std::string Controller::GetDefaultOutlineProperties() const
{
return mImpl->mOutlineDefaults ? mImpl->mOutlineDefaults->properties : EMPTY_STRING;
}
InputFontHandler::SetInputFontFamily(*this, fontFamily);
}
-const std::string& Controller::GetInputFontFamily() const
+std::string Controller::GetInputFontFamily() const
{
return InputFontHandler::GetInputFontFamily(*this);
}
return InputFontHandler::GetInputFontSlant(*this);
}
-void Controller::SetInputFontPointSize(float size)
+void Controller::SetInputFontPointSize(float size, bool defaultFontSizeUpdated)
{
- InputFontHandler::SetInputFontPointSize(*this, size);
+ InputFontHandler::SetInputFontPointSize(*this, size, defaultFontSizeUpdated);
}
float Controller::GetInputFontPointSize() const
InputProperties::SetInputShadowProperties(*this, shadowProperties);
}
-const std::string& Controller::GetInputShadowProperties() const
+std::string Controller::GetInputShadowProperties() const
{
return InputProperties::GetInputShadowProperties(*this);
}
InputProperties::SetInputUnderlineProperties(*this, underlineProperties);
}
-const std::string& Controller::GetInputUnderlineProperties() const
+std::string Controller::GetInputUnderlineProperties() const
{
return InputProperties::GetInputUnderlineProperties(*this);
}
InputProperties::SetInputEmbossProperties(*this, embossProperties);
}
-const std::string& Controller::GetInputEmbossProperties() const
+std::string Controller::GetInputEmbossProperties() const
{
return InputProperties::GetInputEmbossProperties(*this);
}
InputProperties::SetInputOutlineProperties(*this, outlineProperties);
}
-const std::string& Controller::GetInputOutlineProperties() const
+std::string Controller::GetInputOutlineProperties() const
{
return InputProperties::GetInputOutlineProperties(*this);
}
}
}
-const std::string& Controller::GetInputStrikethroughProperties() const
+std::string Controller::GetInputStrikethroughProperties() const
{
return (NULL != mImpl->mEventData) ? mImpl->mEventData->mInputStyle.strikethroughProperties : EMPTY_STRING;
}
Relayouter::FitPointSizeforLayout(*this, layoutSize);
}
+void Controller::FitArrayPointSizeforLayout(Size layoutSize)
+{
+ Relayouter::FitArrayPointSizeforLayout(*this, layoutSize);
+}
+
float Controller::GetHeightForWidth(float width)
{
return Relayouter::GetHeightForWidth(*this, width);
return mImpl->mModel->GetNumberOfLines();
}
-const ModelInterface* const Controller::GetTextModel() const
+const ModelInterface* Controller::GetTextModel() const
{
return mImpl->mModel.Get();
}
return mImpl->mModel->mVisualModel->GetCharacterSpacing();
}
+void Controller::SetVisualTransformOffset(Vector2 offset)
+{
+ mImpl->mModel->mVisualTransformOffset = offset;
+}
+
+void Controller::SetBackgroundWithCutoutEnabled(bool cutout)
+{
+ mImpl->mModel->mVisualModel->SetBackgroundWithCutoutEnabled(cutout);
+ RequestRelayout();
+}
+
+bool Controller::IsBackgroundWithCutoutEnabled() const
+{
+ return mImpl->mModel->mVisualModel->IsBackgroundWithCutoutEnabled();
+}
+
+void Controller::SetBackgroundColorWithCutout(const Vector4& color)
+{
+ mImpl->mModel->mVisualModel->SetBackgroundColorWithCutout(color);
+ mImpl->RequestRelayout();
+}
+
+const Vector4 Controller::GetBackgroundColorWithCutout() const
+{
+ return mImpl->mModel->mVisualModel->GetBackgroundColorWithCutout();
+}
+
Controller::UpdateTextType Controller::Relayout(const Size& size, Dali::LayoutDirection::Type layoutDirection)
{
return Relayouter::Relayout(*this, size, layoutDirection);
return GetCharacterBoundingRect(mImpl->mModel, charIndex);
}
+int Controller::GetCharacterIndexAtPosition(float visualX, float visualY)
+{
+ return GetCharIndexAtPosition(mImpl->mModel, visualX, visualY);
+}
+
Rect<> Controller::GetTextBoundingRectangle(CharacterIndex startIndex, CharacterIndex endIndex)
{
Vector<Vector2> sizeList;
return mImpl->IsInputStyleChangedSignalsQueueEmpty();
}
-void Controller::ProcessInputStyleChangedSignals()
+void Controller::RequestProcessInputStyleChangedSignals()
{
- mImpl->ProcessInputStyleChangedSignals();
+ if(Dali::Adaptor::IsAvailable() && !mImpl->mProcessorRegistered)
+ {
+ mImpl->mProcessorRegistered = true;
+ Dali::Adaptor::Get().RegisterProcessor(*this, true);
+ }
+}
+
+void Controller::OnIdleSignal()
+{
+ if(mImpl->mIdleCallback)
+ {
+ mImpl->mIdleCallback = NULL;
+
+ mImpl->ProcessInputStyleChangedSignals();
+ }
}
void Controller::KeyboardFocusGainEvent()
return mImpl->CutText();
}
-void Controller::PasteText()
+void Controller::PasteClipboardItemEvent(uint32_t id, const char* mimeType, const char* data)
{
- mImpl->RequestGetTextFromClipboard(); // Request clipboard service to retrieve an item
+ // Upon receiving the data, it is important to disconnect the signal
+ // to avoid potential unintended pasting caused by subsequent requests.
+ mImpl->mClipboard.DataReceivedSignal().Disconnect(this, &Controller::PasteClipboardItemEvent);
+
+ // If the id is 0u, it is an invalid response.
+ if(id == 0u)
+ {
+ return;
+ }
+
+ // text-controller allows only plain text type.
+ if(!strncmp(mimeType, MIME_TYPE_TEXT_PLAIN, strlen(MIME_TYPE_TEXT_PLAIN)))
+ {
+ EventHandler::PasteClipboardItemEvent(*this, data);
+ }
+ else if(!strncmp(mimeType, MIME_TYPE_HTML, strlen(MIME_TYPE_HTML)))
+ {
+ // This does not mean that text controls can parse html.
+ // This is temporary code, as text controls do not support html type data.
+ // Simply remove the tags inside the angle brackets.
+ // Once multiple types and data can be stored in the clipboard, this code should be removed.
+ std::regex reg("<[^>]*>");
+ std::string result = regex_replace(data, reg, "");
+
+ EventHandler::PasteClipboardItemEvent(*this, result.c_str());
+ }
}
-InputMethodContext::CallbackData Controller::OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
+void Controller::PasteText()
{
- return EventHandler::OnInputMethodContextEvent(*this, inputMethodContext, inputMethodContextEvent);
+ if(mImpl->EnsureClipboardCreated())
+ {
+ // Connect the signal before calling GetData() of the clipboard.
+ mImpl->mClipboard.DataReceivedSignal().Connect(this, &Controller::PasteClipboardItemEvent);
+
+ // If there is no plain text type data on the clipboard, request html type data.
+ std::string mimeType = mImpl->mClipboard.HasType(MIME_TYPE_TEXT_PLAIN) ? MIME_TYPE_TEXT_PLAIN : MIME_TYPE_HTML;
+
+ // Request clipboard service to retrieve an item.
+ uint id = mImpl->mClipboard.GetData(mimeType);
+ if(id == 0u)
+ {
+ // If the return id is 0u, the signal is not emitted, we must disconnect signal here.
+ mImpl->mClipboard.DataReceivedSignal().Disconnect(this, &Controller::PasteClipboardItemEvent);
+ }
+ }
}
-void Controller::PasteClipboardItemEvent()
+InputMethodContext::CallbackData Controller::OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
{
- EventHandler::PasteClipboardItemEvent(*this);
+ return EventHandler::OnInputMethodContextEvent(*this, inputMethodContext, inputMethodContextEvent);
}
void Controller::GetTargetSize(Vector2& targetSize)
return mImpl->GetAnchorIndex(characterOffset);
}
+void Controller::Process(bool postProcess)
+{
+ if(Dali::Adaptor::IsAvailable() && mImpl->mProcessorRegistered)
+ {
+ Dali::Adaptor& adaptor = Dali::Adaptor::Get();
+
+ adaptor.UnregisterProcessor(*this, true);
+ mImpl->mProcessorRegistered = false;
+
+ if(NULL == mImpl->mIdleCallback)
+ {
+ // @note: The callback manager takes the ownership of the callback object.
+ mImpl->mIdleCallback = MakeCallback(this, &Controller::OnIdleSignal);
+ if(DALI_UNLIKELY(!adaptor.AddIdle(mImpl->mIdleCallback, false)))
+ {
+ DALI_LOG_ERROR("Fail to add idle callback for text controller style changed signals queue. Skip these callbacks\n");
+
+ // Clear queue forcely.
+ if(mImpl->mEventData)
+ {
+ mImpl->mEventData->mInputStyleChangedQueue.Clear();
+ }
+
+ // Set the pointer to null as the callback manager deletes the callback even AddIdle failed.
+ mImpl->mIdleCallback = NULL;
+ }
+ }
+ }
+}
+
Controller::Controller(ControlInterface* controlInterface,
EditableControlInterface* editableControlInterface,
SelectableControlInterface* selectableControlInterface,
Controller::~Controller()
{
- delete mImpl;
+ if(Dali::Adaptor::IsAvailable())
+ {
+ if(mImpl->mProcessorRegistered)
+ {
+ Dali::Adaptor::Get().UnregisterProcessor(*this, true);
+ }
+ if(mImpl->mIdleCallback)
+ {
+ Dali::Adaptor::Get().RemoveIdle(mImpl->mIdleCallback);
+ }
+ }
}
} // namespace Dali::Toolkit::Text
projects / platform / core / uifw / dali-toolkit.git / blobdiff