static bool gAnchorClickedCallBackCalled;
static bool gAnchorClickedCallBackNotCalled;
+static bool gTextFitChangedCallBackCalled;
+
struct CallbackFunctor
{
CallbackFunctor(bool* callbackFlag)
}
}
+static void TestTextFitChangedCallback(TextLabel control)
+{
+ tet_infoline(" TestTextFitChangedCallback");
+ gTextFitChangedCallBackCalled = true;
+}
+
bool DaliTestCheckMaps( const Property::Map& mapGet, const Property::Map& mapSet, const std::vector<std::string>& indexConversionTable = std::vector<std::string>() )
{
const Property::Map::SizeType size = mapGet.Count();
label.SetProperty( Actor::Property::SIZE, size );
label.SetProperty( TextLabel::Property::TEXT, "Hello world" );
+ // connect to the text git changed signal.
+ ConnectionTracker* testTracker = new ConnectionTracker();
+ DevelTextLabel::TextFitChangedSignal(label).Connect(&TestTextFitChangedCallback);
+ bool textFitChangedSignal = false;
+ label.ConnectSignal(testTracker, "textFitChanged", CallbackFunctor(&textFitChangedSignal));
+ gTextFitChangedCallBackCalled = false;
+
// check point size
Property::Map textFitMapSet;
textFitMapSet["enable"] = true;
const Vector3 EXPECTED_NATURAL_SIZE( 450.0f, 96.0f, 0.0f );
DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, label.GetNaturalSize(), TEST_LOCATION );
+ DALI_TEST_CHECK(gTextFitChangedCallBackCalled);
+ DALI_TEST_CHECK(textFitChangedSignal);
+
// check pixel size
textFitMapSet.Clear();
textFitMapSet["enable"] = true;
END_TEST;
-}
\ No newline at end of file
+}
return GetImpl(textLabel).AnchorClickedSignal();
}
+TextFitChangedSignalType& TextFitChangedSignal(TextLabel textLabel)
+{
+ return GetImpl(textLabel).TextFitChangedSignal();
+}
+
} // namespace DevelTextLabel
} // namespace Toolkit
using AnchorClickedSignalType = Signal<void(TextLabel, const char*, uint32_t)>;
/**
+ * @brief TextFit property changed signal type.
+ */
+using TextFitChangedSignalType = Signal<void(TextLabel)>;
+
+/**
* @brief This signal is emitted when the anchor is clicked.
*
* A callback of the following type may be connected:
*/
DALI_TOOLKIT_API AnchorClickedSignalType& AnchorClickedSignal(TextLabel textLabel);
+/**
+ * @brief This signal is emitted when the textfit property is changed.
+ *
+ * A callback of the following type may be connected:
+ * @code
+ * void YourCallbackName(TextLabel textLabel);
+ * @endcode
+ * @param[in] textLabel The instance of TextLabel.
+ * @return The signal to connect to.
+ */
+DALI_TOOLKIT_API TextFitChangedSignalType& TextFitChangedSignal(TextLabel textLabel);
+
} // namespace DevelTextLabel
} // namespace Toolkit
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_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
case Toolkit::DevelTextLabel::Property::TEXT_FIT:
{
ParseTextFitProperty(impl.mController, value.GetMap());
+ impl.mController->SetTextFitChanged(true);
break;
}
case Toolkit::DevelTextLabel::Property::MIN_LINE_SIZE:
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;
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();
mTextUpdateNeeded = false;
}
+
+ if(mController->IsTextFitChanged())
+ {
+ EmitTextFitChangedSignal();
+ mController->SetTextFitChanged(false);
+ }
}
void TextLabel::RequestTextRelayout()
mController->ChangedLayoutDirection();
}
+void TextLabel::EmitTextFitChangedSignal()
+{
+ Dali::Toolkit::TextLabel handle(GetOwner());
+ mTextFitChangedSignal.Emit(handle);
+}
+
TextLabel::TextLabel()
: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
mRenderingBackend(DEFAULT_RENDERING_BACKEND),
DevelTextLabel::AnchorClickedSignalType& AnchorClickedSignal();
/**
+ * @copydoc Dali::Toollkit::TextLabel::TextFitChangedSignal()
+ */
+ DevelTextLabel::TextFitChangedSignalType& TextFitChangedSignal();
+
+ /**
* Connects a callback function with the object's signals.
* @param[in] object The object providing the signal.
* @param[in] tracker Used to disconnect the signal.
*/
void OnLayoutDirectionChanged(Actor actor, LayoutDirection::Type type);
+ /**
+ * @brief Emits TextFitChanged signal.
+ */
+ void EmitTextFitChangedSignal();
+
private: // Data
Text::ControllerPtr mController;
Text::TextScrollerPtr mTextScroller;
// Signals
Toolkit::DevelTextLabel::AnchorClickedSignalType mAnchorClickedSignal;
+ Toolkit::DevelTextLabel::TextFitChangedSignalType mTextFitChangedSignal;
int mRenderingBackend;
bool mTextUpdateNeeded : 1;
float mTextFitMaxSize; ///< Maximum Font Size for text fit. Default 100
float mTextFitStepSize; ///< Step Size for font intervalse. Default 1
bool mTextFitEnabled : 1; ///< Whether the text's fit is enabled.
+ float mTextFitChanged; ///< Whether the text fit property has changed.
float mFontSizeScale; ///< Scale value for Font Size. Default 1.0
bool mIsLayoutDirectionChanged : 1; ///< Whether the layout has changed.
float minPointSize = impl.mTextFitMinSize;
float maxPointSize = impl.mTextFitMaxSize;
float pointInterval = impl.mTextFitStepSize;
+ float currentFitPointSize = impl.mFontDefaults->mFitPointSize;
model->mElideEnabled = false;
Vector<float> pointSizeArray;
}
model->mElideEnabled = actualellipsis;
+ if(currentFitPointSize != pointSizeArray[bestSizeIndex])
+ {
+ impl.mTextFitChanged = true;
+ }
impl.mFontDefaults->mFitPointSize = pointSizeArray[bestSizeIndex];
impl.mFontDefaults->sizeDefined = true;
controller.ClearFontData();
return mImpl->mTextFitEnabled;
}
+void Controller::SetTextFitChanged(bool changed)
+{
+ mImpl->mTextFitChanged = changed;
+}
+
+bool Controller::IsTextFitChanged() const
+{
+ return mImpl->mTextFitChanged;
+}
+
void Controller::SetTextFitMinSize(float minSize, FontSizeType type)
{
mImpl->mTextFitMinSize = (type == POINT_SIZE) ? minSize : ConvertPixelToPoint(minSize);
return mImpl->mTextFitContentSize;
}
+float Controller::GetTextFitPointSize() const
+{
+ return mImpl->mFontDefaults ? mImpl->mFontDefaults->mFitPointSize : 0.0f;
+}
+
void Controller::SetPlaceholderTextElideEnabled(bool enabled)
{
PlaceholderHandler::SetPlaceholderTextElideEnabled(*this, enabled);
Vector2 GetTextFitContentSize() const;
/**
+ * @brief Retrieve the fited point size.
+ *
+ * @return The fited point size.
+ */
+ float GetTextFitPointSize() const;
+
+ /**
+ * @brief Sets whether the text fit properties have changed.
+ *
+ * @param[in] changed Whether to changed the text fit.
+ */
+ void SetTextFitChanged(bool changed);
+
+ /**
+ * @brief Whether the text fit properties are changed or not.
+ *
+ * @return True if the text fit properties are changed
+ */
+ bool IsTextFitChanged() const;
+
+ /**
* @brief Enable or disable the placeholder text elide.
* @param enabled Whether to enable the placeholder text elide.
*/