From 8df5ba295584353621701d1064c6c89782967507 Mon Sep 17 00:00:00 2001 From: ssabah Date: Sun, 11 Dec 2022 15:04:15 +0300 Subject: [PATCH 1/1] Spannable: Add StrikethroughSpan StrikethroughSpan: Span to change the strikethrough properties (Color,Heighth) of characters This patch should be preceded by the patch below: https://review.tizen.org/gerrit/c/platform/core/uifw/dali-toolkit/+/285217 Change-Id: Id7823ea49b19fed3ae1a0a9a73e55538ccd2ad2e --- .../utc-Dali-Text-TextSpannable.cpp | 98 ++++++++++--- automated-tests/src/dali-toolkit/CMakeLists.txt | 1 + .../utc-Dali-Text-StrikethroughSpan.cpp | 124 ++++++++++++++++ dali-toolkit/devel-api/file.list | 2 + .../devel-api/text/spans/strikethrough-span.cpp | 82 +++++++++++ .../devel-api/text/spans/strikethrough-span.h | 158 +++++++++++++++++++++ dali-toolkit/internal/file.list | 1 + .../text-controller-impl-model-updater.cpp | 3 +- .../text/controller/text-controller-impl.cpp | 3 + dali-toolkit/internal/text/logical-model-impl.cpp | 3 +- dali-toolkit/internal/text/logical-model-impl.h | 3 +- .../spannable/spans/strikethrough-span-impl.cpp | 115 +++++++++++++++ .../text/spannable/spans/strikethrough-span-impl.h | 155 ++++++++++++++++++++ 13 files changed, 722 insertions(+), 26 deletions(-) create mode 100644 automated-tests/src/dali-toolkit/utc-Dali-Text-StrikethroughSpan.cpp create mode 100644 dali-toolkit/devel-api/text/spans/strikethrough-span.cpp create mode 100644 dali-toolkit/devel-api/text/spans/strikethrough-span.h create mode 100644 dali-toolkit/internal/text/spannable/spans/strikethrough-span-impl.cpp create mode 100644 dali-toolkit/internal/text/spannable/spans/strikethrough-span-impl.h diff --git a/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-TextSpannable.cpp b/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-TextSpannable.cpp index 6af7bb0..40f51de 100644 --- a/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-TextSpannable.cpp +++ b/automated-tests/src/dali-toolkit-internal/utc-Dali-Text-TextSpannable.cpp @@ -23,8 +23,13 @@ #include #include #include +#include +#include +#include #include #include +#include +#include #include #include #include @@ -37,10 +42,6 @@ #include #include #include -#include -#include -#include -#include using namespace Dali; using namespace Toolkit; @@ -51,6 +52,19 @@ const std::string DEFAULT_FONT_DIR("/resources/fonts"); const float PIXEL_FORMAT_64_FACTOR = 64.f; ///< 64.f is used to convert from point size to 26.6 pixel format. } // namespace +Text::SpannableString CreateSpannableStringForStrikethroughSpan() +{ + Text::SpannableString spannableString = Text::SpannableString::New("Hello World"); + DALI_TEST_CHECK(spannableString); + + auto isAddedStrikethroughSpan = spannableString.AttachSpan( + Text::StrikethroughSpan::New(Color::GREEN, 5.0f), + Text::Range::New(5u, 7u)); + DALI_TEST_CHECK(isAddedStrikethroughSpan); + + return spannableString; +} + Text::SpannableString CreateSpannableStringForForegroundColorSpan() { Text::SpannableString spannableString = Text::SpannableString::New("Hello مرحبا"); @@ -100,8 +114,8 @@ Text::SpannableString CreateSpannableStringForCharacterSpacing() DALI_TEST_CHECK(spannableString); auto isCharacterSpacingSpan = spannableString.AttachSpan( - Text::CharacterSpacingSpan::New(5.2f), - Text::Range::New(5u, 7u)); + Text::CharacterSpacingSpan::New(5.2f), + Text::Range::New(5u, 7u)); DALI_TEST_CHECK(isCharacterSpacingSpan); return spannableString; @@ -112,12 +126,11 @@ Text::SpannableString CreateSpannableStringForBoldSpan() Text::SpannableString spannableString = Text::SpannableString::New("Hello"); DALI_TEST_CHECK(spannableString); - auto boldspan = Dali::Toolkit::Text::BoldSpan::New(); - auto isBoldSpan = spannableString.AttachSpan(boldspan,Dali::Toolkit::Text::Range::New(0u, 3u)); + auto boldspan = Dali::Toolkit::Text::BoldSpan::New(); + auto isBoldSpan = spannableString.AttachSpan(boldspan, Dali::Toolkit::Text::Range::New(0u, 3u)); DALI_TEST_CHECK(isBoldSpan); return spannableString; - } Text::SpannableString CreateSpannableStringForItalicSpan() @@ -126,8 +139,8 @@ Text::SpannableString CreateSpannableStringForItalicSpan() DALI_TEST_CHECK(spannableString); auto isAddedItalic = spannableString.AttachSpan( - Text::ItalicSpan::New(), - Text::Range::New(0u, 3u)); + Text::ItalicSpan::New(), + Text::Range::New(0u, 3u)); DALI_TEST_CHECK(isAddedItalic); return spannableString; @@ -135,14 +148,13 @@ Text::SpannableString CreateSpannableStringForItalicSpan() Text::SpannableString CreateSpannableStringForBackgroundColorSpan() { - Text::SpannableString spannableString = Text::SpannableString::New("Hello مرحبا"); DALI_TEST_CHECK(spannableString); auto isAddedGreen = spannableString.AttachSpan( - Text::BackgroundColorSpan::New(Color::GREEN), - Text::Range::New(5u, 7u)); + Text::BackgroundColorSpan::New(Color::GREEN), + Text::Range::New(5u, 7u)); DALI_TEST_CHECK(isAddedGreen); return spannableString; @@ -437,7 +449,7 @@ int UtcDaliToolkitTextLabelSetSpannedText_CharacterSpacingSpan(void) application.SendNotification(); application.Render(); - Toolkit::Internal::TextLabel& labelImpl = GetImpl(textLabel); + Toolkit::Internal::TextLabel& labelImpl = GetImpl(textLabel); const Vector characterSpacing = labelImpl.GetTextController()->GetTextModel()->GetCharacterSpacingGlyphRuns(); DALI_TEST_EQUALS(1, characterSpacing.Count(), TEST_LOCATION); END_TEST; @@ -461,13 +473,13 @@ int UtcDaliToolkitTextLabelSetSpannedText_BoldSpan(void) application.SendNotification(); application.Render(); - Toolkit::Internal::TextLabel& labelImpl = GetImpl(textLabel); + Toolkit::Internal::TextLabel& labelImpl = GetImpl(textLabel); const Vector& validFonts = labelImpl.GetTextController()->GetTextModel()->GetFontRuns(); DALI_TEST_EQUALS(validFonts.Count(), 2, TEST_LOCATION); - DALI_TEST_EQUALS(validFonts[0].characterRun.characterIndex,0, TEST_LOCATION); - DALI_TEST_EQUALS(validFonts[0].characterRun.GetEndCharacterIndex(),3, TEST_LOCATION); + DALI_TEST_EQUALS(validFonts[0].characterRun.characterIndex, 0, TEST_LOCATION); + DALI_TEST_EQUALS(validFonts[0].characterRun.GetEndCharacterIndex(), 3, TEST_LOCATION); DALI_TEST_EQUALS(validFonts[0].isBoldRequired, true, TEST_LOCATION); END_TEST; } @@ -488,8 +500,8 @@ int UtcDaliToolkitTextLabelSetSpannedText_ItalicSpan(void) application.SendNotification(); application.Render(); - Toolkit::Internal::TextLabel& labelImpl = GetImpl(textLabel); - const Vector& validFontsItalic = labelImpl.GetTextController()->GetTextModel()->GetFontRuns(); + Toolkit::Internal::TextLabel& labelImpl = GetImpl(textLabel); + const Vector& validFontsItalic = labelImpl.GetTextController()->GetTextModel()->GetFontRuns(); DALI_TEST_EQUALS(validFontsItalic.Count(), 2, TEST_LOCATION); DALI_TEST_EQUALS(validFontsItalic[0].characterRun.characterIndex, 0, TEST_LOCATION); @@ -500,7 +512,6 @@ int UtcDaliToolkitTextLabelSetSpannedText_ItalicSpan(void) int UtcDaliToolkitTextLabelSetSpannedText_BackgroundColorSpan(void) { - ToolkitTestApplication application; tet_infoline("UtcDaliToolkitTextLabelSetSpannedText_BackgroundColorSpan"); @@ -515,11 +526,52 @@ int UtcDaliToolkitTextLabelSetSpannedText_BackgroundColorSpan(void) application.SendNotification(); application.Render(); - Toolkit::Internal::TextLabel& labelImpl = GetImpl(textLabel); - const Text::ColorIndex* const backgroundColorIndicesBuffer = labelImpl.GetTextController()->GetTextModel()->GetBackgroundColorIndices(); + Toolkit::Internal::TextLabel& labelImpl = GetImpl(textLabel); + const Text::ColorIndex* const backgroundColorIndicesBuffer = labelImpl.GetTextController()->GetTextModel()->GetBackgroundColorIndices(); CheckColorIndices(backgroundColorIndicesBuffer, 4u, {0u, 5u, 7u, 10u}, {0u, 1u, 1u, 0u}); END_TEST; } +int UtcDaliToolkitTextLabelSetSpannedText_StrikethroughSpan(void) +{ + ToolkitTestApplication application; + + tet_infoline(" UtcDaliToolkitTextLabelSetSpannedText_StrikethroughSpan "); + + Dali::Toolkit::Text::StrikethroughStyleProperties expectedProperties = { + Color::GREEN, + 5u, + true, + true}; + + TextLabel textLabel = TextLabel::New(); + + DALI_TEST_CHECK(textLabel); + + application.GetScene().Add(textLabel); + + Text::SpannableString spannableString = CreateSpannableStringForStrikethroughSpan(); + Text::SetSpannedText(textLabel, spannableString); + + application.SendNotification(); + application.Render(); + + Toolkit::Internal::TextLabel& labelImpl = GetImpl(textLabel); + + const Text::Length numberOfStrikethroughRuns = labelImpl.GetTextController()->GetTextModel()->GetNumberOfStrikethroughRuns(); + + DALI_TEST_EQUALS(numberOfStrikethroughRuns, 1u, TEST_LOCATION); + + Vector strikethroughRuns; + strikethroughRuns.Resize(numberOfStrikethroughRuns); + + labelImpl.GetTextController()->GetTextModel()->GetStrikethroughRuns(strikethroughRuns.Begin(), 0u, numberOfStrikethroughRuns); + + DALI_TEST_EQUALS(strikethroughRuns[0].glyphRun.glyphIndex, 5u, TEST_LOCATION); + DALI_TEST_EQUALS(strikethroughRuns[0].glyphRun.numberOfGlyphs, 3u, TEST_LOCATION); + DALI_TEST_CHECK(strikethroughRuns[0].properties == expectedProperties); + + END_TEST; +} \ No newline at end of file diff --git a/automated-tests/src/dali-toolkit/CMakeLists.txt b/automated-tests/src/dali-toolkit/CMakeLists.txt index b627f3a..d07288b 100755 --- a/automated-tests/src/dali-toolkit/CMakeLists.txt +++ b/automated-tests/src/dali-toolkit/CMakeLists.txt @@ -50,6 +50,7 @@ SET(TC_SOURCES utc-Dali-Text-Range.cpp utc-Dali-Text-SpannableString.cpp utc-Dali-Text-UnderlineSpan.cpp + utc-Dali-Text-StrikethroughSpan.cpp utc-Dali-TextEditor.cpp utc-Dali-TextField.cpp utc-Dali-TextGeometry.cpp diff --git a/automated-tests/src/dali-toolkit/utc-Dali-Text-StrikethroughSpan.cpp b/automated-tests/src/dali-toolkit/utc-Dali-Text-StrikethroughSpan.cpp new file mode 100644 index 0000000..f16efee --- /dev/null +++ b/automated-tests/src/dali-toolkit/utc-Dali-Text-StrikethroughSpan.cpp @@ -0,0 +1,124 @@ +/* + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include + +using namespace Dali; +using namespace Toolkit; + +int UtcDaliToolkitTextStrikethroughSpanNew(void) +{ + ToolkitTestApplication application; + + tet_infoline(" UtcDaliToolkitTextStrikethroughSpanNew"); + + auto strikethroughSpan = Text::StrikethroughSpan::New(); + DALI_TEST_CHECK(strikethroughSpan); + + END_TEST; +} + +int UtcDaliToolkitTextStrikethroughSpanNewColorHeight(void) +{ + ToolkitTestApplication application; + + tet_infoline(" UtcDaliToolkitTextStrikethroughSpanNewColorHeight"); + + auto strikethroughSpan = Text::StrikethroughSpan::New(Color::GREEN, 5.0f); + DALI_TEST_CHECK(strikethroughSpan); + + END_TEST; +} + +int UtcDaliToolkitTextStrikethroughSpanGetColor(void) +{ + ToolkitTestApplication application; + + tet_infoline(" UtcDaliToolkitTextStrikethroughSpanGetColor"); + + auto strikethroughSpan = Text::StrikethroughSpan::New(Color::GREEN, 5.0f); + + DALI_TEST_CHECK(strikethroughSpan); + DALI_TEST_EQUALS(Color::GREEN, strikethroughSpan.GetColor(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliToolkitTextStrikethroughSpanIsColorDefined(void) + +{ + ToolkitTestApplication application; + + tet_infoline(" UtcDaliToolkitTextStrikethroughSpanIsColorDefined"); + + auto strikethroughSpan = Text::StrikethroughSpan::New(Color::GREEN, 5.0f); + + DALI_TEST_CHECK(strikethroughSpan); + DALI_TEST_EQUALS(true, strikethroughSpan.IsColorDefined(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliToolkitTextStrikethroughSpanGetHeight(void) + +{ + ToolkitTestApplication application; + + tet_infoline(" UtcDaliToolkitTextStrikethroughSpanGetHeight"); + + auto strikethroughSpan = Text::StrikethroughSpan::New(Color::GREEN, 5.0f); + + DALI_TEST_CHECK(strikethroughSpan); + DALI_TEST_EQUALS(5.0f, strikethroughSpan.GetHeight(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliToolkitTextStrikethroughSpanIsHeightDefined(void) + +{ + ToolkitTestApplication application; + + tet_infoline(" UtcDaliToolkitTextStrikethroughSpanIsHeightDefined"); + + auto strikethroughSpan = Text::StrikethroughSpan::New(Color::GREEN, 5.0f); + + DALI_TEST_CHECK(strikethroughSpan); + DALI_TEST_EQUALS(true, strikethroughSpan.IsHeightDefined(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliToolkitTextStrikethroughSpanStrikethroughSpanDownCast(void) +{ + ToolkitTestApplication application; + + tet_infoline(" UtcDaliToolkitTextStrikethroughSpanStrikethroughSpanDownCast"); + + Text::BaseSpan baseSpan = Text::StrikethroughSpan::New(); + DALI_TEST_CHECK(baseSpan); + + Text::StrikethroughSpan strikethroughSpan = Text::StrikethroughSpan::DownCast(baseSpan); + DALI_TEST_CHECK(strikethroughSpan); + + END_TEST; +} \ No newline at end of file diff --git a/dali-toolkit/devel-api/file.list b/dali-toolkit/devel-api/file.list index 8443b0e..248ab7f 100755 --- a/dali-toolkit/devel-api/file.list +++ b/dali-toolkit/devel-api/file.list @@ -69,6 +69,7 @@ SET( devel_api_src_files ${devel_api_src_dir}/text/spans/base-span.cpp ${devel_api_src_dir}/text/spans/foreground-color-span.cpp ${devel_api_src_dir}/text/spans/character-spacing-span.cpp + ${devel_api_src_dir}/text/spans/strikethrough-span.cpp ${devel_api_src_dir}/text/spans/font-span.cpp ${devel_api_src_dir}/text/spans/underline-span.cpp ${devel_api_src_dir}/text/spans/bold-span.cpp @@ -256,6 +257,7 @@ SET( devel_api_text_header_files ${devel_api_src_dir}/text/spans/base-span.h ${devel_api_src_dir}/text/spans/foreground-color-span.h ${devel_api_src_dir}/text/spans/character-spacing-span.h + ${devel_api_src_dir}/text/spans/strikethrough-span.h ${devel_api_src_dir}/text/spans/font-span.h ${devel_api_src_dir}/text/spans/underline-span.h ${devel_api_src_dir}/text/spans/bold-span.h diff --git a/dali-toolkit/devel-api/text/spans/strikethrough-span.cpp b/dali-toolkit/devel-api/text/spans/strikethrough-span.cpp new file mode 100644 index 0000000..3d04a54 --- /dev/null +++ b/dali-toolkit/devel-api/text/spans/strikethrough-span.cpp @@ -0,0 +1,82 @@ +/* + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER +#include + +// INTERNAL INCLUDES +#include + +namespace Dali +{ +namespace Toolkit +{ +namespace Text +{ +StrikethroughSpan StrikethroughSpan::New() +{ + return Internal::StrikethroughSpan::New(); +} + +StrikethroughSpan StrikethroughSpan::New(Vector4 color, float height) +{ + return Internal::StrikethroughSpan::New(color, height); +} + +StrikethroughSpan::StrikethroughSpan(Internal::StrikethroughSpan* internal) +: BaseSpan(internal) +{ +} + +StrikethroughSpan::StrikethroughSpan() = default; +StrikethroughSpan::StrikethroughSpan(const StrikethroughSpan& rhs) = default; +StrikethroughSpan::StrikethroughSpan(StrikethroughSpan&& rhs) = default; +StrikethroughSpan& StrikethroughSpan::operator=(const StrikethroughSpan& rhs) = default; +StrikethroughSpan& StrikethroughSpan::operator=(StrikethroughSpan&& rhs) = default; +StrikethroughSpan::~StrikethroughSpan() = default; + +//Methods +const Vector4 StrikethroughSpan::GetColor() const +{ + return GetImplementation(*this).GetColor(); +} + +bool StrikethroughSpan::IsColorDefined() const +{ + return GetImplementation(*this).IsColorDefined(); +} + +const float StrikethroughSpan::GetHeight() const +{ + return GetImplementation(*this).GetHeight(); +} + +bool StrikethroughSpan::IsHeightDefined() const +{ + return GetImplementation(*this).IsHeightDefined(); +} + +StrikethroughSpan StrikethroughSpan::DownCast(BaseHandle handle) +{ + return StrikethroughSpan(dynamic_cast(handle.GetObjectPtr())); +} + +} // namespace Text + +} // namespace Toolkit + +} // namespace Dali \ No newline at end of file diff --git a/dali-toolkit/devel-api/text/spans/strikethrough-span.h b/dali-toolkit/devel-api/text/spans/strikethrough-span.h new file mode 100644 index 0000000..de12289 --- /dev/null +++ b/dali-toolkit/devel-api/text/spans/strikethrough-span.h @@ -0,0 +1,158 @@ +#ifndef DALI_TOOLKIT_TEXT_STRIKETHROUGH_SPAN_H +#define DALI_TOOLKIT_TEXT_STRIKETHROUGH_SPAN_H + +/* + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// INTERNAL INCLUDES + +#include +#include +#include +#include + +namespace Dali +{ +namespace Toolkit +{ +namespace Text +{ +namespace Internal DALI_INTERNAL +{ +class StrikethroughSpan; +} + +/** + * @brief StrikethroughSpan is a handle to an object that specifies the strikethrough properties for range of characters. + */ + +class DALI_TOOLKIT_API StrikethroughSpan : public BaseSpan +{ +public: + /** + * @brief Create an initialized StrikethroughSpan. + * + * @return A handle to a newly allocated Dali resource + */ + + static StrikethroughSpan New(); + /** + * @brief Create an initialized StrikethroughSpan. + * + * @param[in] color The color of line. + * @param[in] height The height of line. + * + * @return A handle to a newly allocated Dali resource + */ + static StrikethroughSpan New(Vector4 color, float height); + + /** + * @brief Creates an uninitialized StrikethroughSpan handle. + * + * Calling member functions with an uninitialized StrikethroughSpan handle is not allowed. + */ + StrikethroughSpan(); + + /** + * @brief Copy constructor. + * @param[in] rhs A reference to the copied handle + */ + StrikethroughSpan(const StrikethroughSpan& rhs); + + /** + * @brief Move constructor. + * @param[in] rhs A reference to the handle to move + */ + StrikethroughSpan(StrikethroughSpan&& rhs); + + /** + * @brief Assignment operator. + * @param[in] rhs A reference to the copied handle + * @return A reference to this + */ + StrikethroughSpan& operator=(const StrikethroughSpan& rhs); + + /** + * @brief Move assignment operator. + * @param[in] rhs A reference to the moved handle + * @return A reference to this + */ + StrikethroughSpan& operator=(StrikethroughSpan&& rhs); + + /** + * @brief Non virtual destructor. + */ + ~StrikethroughSpan(); + + /** + * @brief Downcasts to a StrikethroughSpan handle. + * If handle is not a StrikethroughSpan, the returned handle is left uninitialized. + * + * @param[in] handle Handle to an object + * @return StrikethroughSpan handle or an uninitialized handle + */ + static StrikethroughSpan DownCast(BaseHandle handle); + +public: //Methods + /** + * @brief Retrive the color of line. + * + * @return A color value. + */ + const Vector4 GetColor() const; + + /** + * @brief Retrieve whether the color is defined. + * + * @return The return is true if color is defined, otherwise false. + */ + bool IsColorDefined() const; + + /** + * @brief Retrive the height of line. + * + * @return A height value. + */ + const float GetHeight() const; + + /** + * @brief Retrieve whether the height is defined. + * + * @return The return is true if height is defined, otherwise false. + */ + bool IsHeightDefined() const; + +public: // Not intended for application developers + /// @cond internal + + /** + * @brief This constructor is used internally to Create an initialized StrikethroughSpan handle. + * + * @param[in] strikethroughSpan Pointer to internal StrikethroughSpan + */ + explicit DALI_INTERNAL StrikethroughSpan(Internal::StrikethroughSpan* strikethroughSpan); + + /// @endcond +}; + +} // namespace Text + +} // namespace Toolkit + +} // namespace Dali + +#endif // DALI_TOOLKIT_TEXT_STRIKETHROUGH_SPAN_H \ No newline at end of file diff --git a/dali-toolkit/internal/file.list b/dali-toolkit/internal/file.list index 88e4ea8..a7f5397 100644 --- a/dali-toolkit/internal/file.list +++ b/dali-toolkit/internal/file.list @@ -163,6 +163,7 @@ SET( toolkit_src_files ${toolkit_src_dir}/text/spannable/spans/base-span-impl.cpp ${toolkit_src_dir}/text/spannable/spans/foreground-color-span-impl.cpp ${toolkit_src_dir}/text/spannable/spans/character-spacing-span-impl.cpp + ${toolkit_src_dir}/text/spannable/spans/strikethrough-span-impl.cpp ${toolkit_src_dir}/text/spannable/spans/font-span-impl.cpp ${toolkit_src_dir}/text/spannable/spans/underline-span-impl.cpp ${toolkit_src_dir}/text/spannable/spans/bold-span-impl.cpp diff --git a/dali-toolkit/internal/text/controller/text-controller-impl-model-updater.cpp b/dali-toolkit/internal/text/controller/text-controller-impl-model-updater.cpp index 280ebcd..91d7eaa 100644 --- a/dali-toolkit/internal/text/controller/text-controller-impl-model-updater.cpp +++ b/dali-toolkit/internal/text/controller/text-controller-impl-model-updater.cpp @@ -585,7 +585,8 @@ bool ControllerImplModelUpdater::Update(Controller::Impl& impl, OperationsMask o //Mark-up processor case if(impl.mModel->mVisualModel->IsMarkupProcessorEnabled() || impl.mModel->mLogicalModel->mUnderlineRunsUpdated || - impl.mModel->mLogicalModel->mCharacterSpacingRunsUpdated) + impl.mModel->mLogicalModel->mCharacterSpacingRunsUpdated || + impl.mModel->mLogicalModel->mStrikethroughRunsUpdated) { impl.CopyUnderlinedFromLogicalToVisualModels(true); impl.CopyStrikethroughFromLogicalToVisualModels(); diff --git a/dali-toolkit/internal/text/controller/text-controller-impl.cpp b/dali-toolkit/internal/text/controller/text-controller-impl.cpp index 614a754..10ccb16 100644 --- a/dali-toolkit/internal/text/controller/text-controller-impl.cpp +++ b/dali-toolkit/internal/text/controller/text-controller-impl.cpp @@ -1757,6 +1757,9 @@ void Controller::Impl::CopyStrikethroughFromLogicalToVisualModels() mModel->mVisualModel->mStrikethroughRuns.PushBack(strikethroughGlyphRun); } + + // Reset flag. The updates have been applied from logical to visual. + mModel->mLogicalModel->mStrikethroughRunsUpdated = false; } void Controller::Impl::CopyCharacterSpacingFromLogicalToVisualModels() diff --git a/dali-toolkit/internal/text/logical-model-impl.cpp b/dali-toolkit/internal/text/logical-model-impl.cpp index fc50ac4..dcad073 100644 --- a/dali-toolkit/internal/text/logical-model-impl.cpp +++ b/dali-toolkit/internal/text/logical-model-impl.cpp @@ -661,7 +661,8 @@ LogicalModel::LogicalModel() : mBidirectionalLineIndex(0u), mSpannedTextPlaced(false), mUnderlineRunsUpdated(false), - mCharacterSpacingRunsUpdated(false) + mCharacterSpacingRunsUpdated(false), + mStrikethroughRunsUpdated(false) { } diff --git a/dali-toolkit/internal/text/logical-model-impl.h b/dali-toolkit/internal/text/logical-model-impl.h index 1c18010..2db64a2 100644 --- a/dali-toolkit/internal/text/logical-model-impl.h +++ b/dali-toolkit/internal/text/logical-model-impl.h @@ -264,8 +264,9 @@ public: BidirectionalLineRunIndex mBidirectionalLineIndex; ///< The last fetched bidirectional line info. bool mSpannedTextPlaced : 1; ///< Whether the spanned-text is placed. - bool mUnderlineRunsUpdated : 1; /// Whether the UnderlinedCharacterRuns is updated. (Added for SpannedText) + bool mUnderlineRunsUpdated : 1; /// Whether the UnderlinedCharacterRuns is updated. (Added for SpannedText) bool mCharacterSpacingRunsUpdated : 1; // Flag for updating character-spacing. + bool mStrikethroughRunsUpdated : 1; /// Whether the StrikethroughCharacterRuns is updated. (Added for SpannedText) }; } // namespace Text diff --git a/dali-toolkit/internal/text/spannable/spans/strikethrough-span-impl.cpp b/dali-toolkit/internal/text/spannable/spans/strikethrough-span-impl.cpp new file mode 100644 index 0000000..fae9a46 --- /dev/null +++ b/dali-toolkit/internal/text/spannable/spans/strikethrough-span-impl.cpp @@ -0,0 +1,115 @@ +/* + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// CLASS HEADER +#include + +// INTERNAL INCLUDES +#include +#include + +namespace Dali +{ +namespace Toolkit +{ +namespace Text +{ +namespace Internal +{ +struct StrikethroughSpan::Impl +{ + StrikethroughStyleProperties mStrikethroughProperties; ///< The properties of strikethrough style. +}; + +StrikethroughSpan::StrikethroughSpan() +: BaseSpan() +{ + mImpl = std::make_unique(); +} + +StrikethroughSpan ::~StrikethroughSpan() +{ +} + +Dali::Toolkit::Text::StrikethroughSpan StrikethroughSpan::New() +{ + StrikethroughSpanPtr object = new StrikethroughSpan(); + Dali::Toolkit::Text::StrikethroughSpan handle = Dali::Toolkit::Text::StrikethroughSpan(object.Get()); + return handle; +} + +Dali::Toolkit::Text::StrikethroughSpan StrikethroughSpan::New(Vector4 color, float height) +{ + StrikethroughSpanPtr object = new StrikethroughSpan(); + object->SetColor(color); + object->SetHeight(height); + Dali::Toolkit::Text::StrikethroughSpan handle = Dali::Toolkit::Text::StrikethroughSpan(object.Get()); + + return handle; +} + +//Methods +const Vector4 StrikethroughSpan::GetColor() const +{ + return mImpl->mStrikethroughProperties.color; +} + +bool StrikethroughSpan::IsColorDefined() const +{ + return mImpl->mStrikethroughProperties.colorDefined; +} + +void StrikethroughSpan::SetColor(const Vector4& color) +{ + mImpl->mStrikethroughProperties.color = color; + mImpl->mStrikethroughProperties.colorDefined = true; +} + +const float StrikethroughSpan::GetHeight() const +{ + return mImpl->mStrikethroughProperties.height; +} + +bool StrikethroughSpan::IsHeightDefined() const +{ + return mImpl->mStrikethroughProperties.heightDefined; +} + +void StrikethroughSpan::SetHeight(const float& height) +{ + mImpl->mStrikethroughProperties.height = height; + mImpl->mStrikethroughProperties.heightDefined = true; +} + +void StrikethroughSpan::CreateStyleCharacterRun(IntrusivePtr& logicalModel, const Dali::Toolkit::Text::Range& range) const + +{ + StrikethroughCharacterRun strikethroughCharacterRun; + strikethroughCharacterRun.characterRun.characterIndex = range.GetStartIndex(); + strikethroughCharacterRun.characterRun.numberOfCharacters = range.GetNumberOfIndices(); + strikethroughCharacterRun.properties = mImpl->mStrikethroughProperties; + logicalModel->mStrikethroughCharacterRuns.PushBack(strikethroughCharacterRun); + logicalModel->mStrikethroughRunsUpdated = true; +} + +} // namespace Internal + +} // namespace Text + +} // namespace Toolkit + +} // namespace Dali \ No newline at end of file diff --git a/dali-toolkit/internal/text/spannable/spans/strikethrough-span-impl.h b/dali-toolkit/internal/text/spannable/spans/strikethrough-span-impl.h new file mode 100644 index 0000000..6c51171 --- /dev/null +++ b/dali-toolkit/internal/text/spannable/spans/strikethrough-span-impl.h @@ -0,0 +1,155 @@ +#ifndef DALI_TOOLKIT_INTERNAL_TEXT_STRIKETHROUGH_SPAN_IMPL_H +#define DALI_TOOLKIT_INTERNAL_TEXT_STRIKETHROUGH_SPAN_IMPL_H + +/* + * 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +// EXTERNAL INCLUDES +#include +#include + +// INTERNAL INCLUDES +#include +#include +#include + +namespace Dali +{ +namespace Toolkit +{ +namespace Text +{ +namespace Internal +{ +class StrikethroughSpan; + +using StrikethroughSpanPtr = IntrusivePtr; + +/** + * @copydoc Dali::Toolkit::Text::StrikethroughSpan + */ + +class StrikethroughSpan : public BaseSpan +{ +public: + /** + * @brief Creates a new StrikethroughSpan object. + * + * @return A new StrikethroughSpan object. + */ + static Dali::Toolkit::Text::StrikethroughSpan New(); + + /** + * @brief Creates a new StrikethroughSpan object. + * + * @param[in] color The color of line. + * @param[in] height The height of line. + * + * @return A new StrikethroughSpan object. + */ + static Dali::Toolkit::Text::StrikethroughSpan New(Vector4 color, float height); + + /** + * Default Constructor + */ + StrikethroughSpan(); + StrikethroughSpan(const StrikethroughSpan&) = delete; ///< Deleted copy constructor + StrikethroughSpan(StrikethroughSpan&&) = delete; ///< Deleted move constructor + StrikethroughSpan& operator=(const StrikethroughSpan&) = delete; ///< Deleted copy assignment operator + StrikethroughSpan& operator=(StrikethroughSpan&&) = delete; ///< Deleted move assignment operator + + /** + * @brief Destructor + * + * A reference counted object may only be deleted by calling Unreference() + */ + ~StrikethroughSpan() override; + +public: //Methods + /** + * @copydoc Dali::Toolkit::Text::StrikethroughSpan::GetColor() + */ + const Vector4 GetColor() const; + + /** + * @copydoc Dali::Toolkit::Text::StrikethroughSpan::IsColorDefined() + */ + bool IsColorDefined() const; + + /** + * @copydoc Dali::Toolkit::Text::StrikethroughSpan::GetHeight() + */ + const float GetHeight() const; + + /** + * @copydoc Dali::Toolkit::Text::StrikethroughSpan::IsHeightDefined() + */ + bool IsHeightDefined() const; + +public: //Methods. Not intended for application developers + /** + * @brief Set the color of underline. + * + * @param[in] color The color of line. + */ + void SetColor(const Vector4& color); + + /** + * @brief Set the height of underline. + * + * @param[in] height The height of line. + */ + void SetHeight(const float& height); + +public: //Methods for internal only + /** + * @copydoc Dali::Toolkit::Text::BaseSpan::CreateStyleCharacterRun + */ + void CreateStyleCharacterRun(IntrusivePtr& logicalModel, const Dali::Toolkit::Text::Range& range) const override; + +private: + struct Impl; + + std::unique_ptr mImpl{nullptr}; + +}; // class StrikethroughSpan + +} // namespace Internal + +// Helpers for public-api forwarding methods + +inline Internal::StrikethroughSpan& GetImplementation(Dali::Toolkit::Text::StrikethroughSpan& foregroundColorSpan) +{ + DALI_ASSERT_ALWAYS(foregroundColorSpan && "foregroundColorSpan handle is empty"); + BaseObject& object = foregroundColorSpan.GetBaseObject(); + return static_cast(object); +} + +inline const Internal::StrikethroughSpan& GetImplementation(const Dali::Toolkit::Text::StrikethroughSpan& foregroundColorSpan) +{ + DALI_ASSERT_ALWAYS(foregroundColorSpan && "foregroundColorSpan handle is empty"); + const BaseObject& object = foregroundColorSpan.GetBaseObject(); + return static_cast(object); +} + +} // namespace Text + +} // namespace Toolkit + +} // namespace Dali + +#endif // DALI_TOOLKIT_INTERNAL_TEXT_STRIKETHROUGH_SPAN_IMPL_H \ No newline at end of file -- 2.7.4