Merge "Change conflict of some visual's Impl namespace" into devel/master
authorEunki Hong <eunkiki.hong@samsung.com>
Wed, 18 May 2022 09:09:18 +0000 (09:09 +0000)
committerGerrit Code Review <gerrit@review>
Wed, 18 May 2022 09:09:18 +0000 (09:09 +0000)
17 files changed:
automated-tests/src/dali-toolkit-internal/utc-Dali-DebugRendering.cpp
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-vector-image-renderer.cpp
automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-vector-image-renderer.h [new file with mode: 0644]
automated-tests/src/dali-toolkit/utc-Dali-Control.cpp
automated-tests/src/dali-toolkit/utc-Dali-ImageView.cpp
automated-tests/src/dali-toolkit/utc-Dali-TextLabel.cpp
automated-tests/src/dali-toolkit/utc-Dali-Visual.cpp
dali-scene-loader/internal/graphics/shaders/default-physically-based-shader.frag
dali-scene-loader/internal/graphics/shaders/default-physically-based-shader.vert
dali-toolkit/internal/text/rendering/text-typesetter.cpp
dali-toolkit/internal/text/rendering/text-typesetter.h
dali-toolkit/internal/visuals/svg/svg-rasterize-thread.cpp
dali-toolkit/internal/visuals/svg/svg-rasterize-thread.h
dali-toolkit/internal/visuals/svg/svg-visual.cpp
dali-toolkit/internal/visuals/svg/svg-visual.h
dali-toolkit/internal/visuals/text/text-visual.cpp
dali-toolkit/internal/visuals/text/text-visual.h

index d39b00c..e2ff409 100755 (executable)
@@ -160,7 +160,7 @@ int UtcDaliDebugRenderingGetVisual1(void)
   propertyMap5.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
   Visual::Base svgVisual = factory.CreateVisual(propertyMap5);
   DALI_TEST_CHECK(svgVisual);
-  TestDebugVisual(application.GetScene(), svgVisual, Visual::SVG, Vector2(100.f, 100.f));
+  TestDebugVisual(application.GetScene(), svgVisual, Visual::SVG, Vector2::ZERO);
 
   // Test that AnimatedImageVisual is replaced with debug visual
   // TEST_GIF_FILE: anim.gif
index cf276f4..d809e66 100644 (file)
@@ -21,6 +21,7 @@
 #include <sys/stat.h>
 #include <toolkit-application.h>
 #include <toolkit-event-thread-callback.h>
+#include <toolkit-vector-image-renderer.h>
 #include <cstring>
 #include <memory>
 
@@ -30,13 +31,15 @@ namespace Internal
 {
 namespace Adaptor
 {
+namespace
+{
+Dali::Internal::Adaptor::VectorImageRenderer* gVectorImageRenderer = nullptr;
+}
+
 class VectorImageRenderer : public Dali::BaseObject
 {
 public:
   VectorImageRenderer()
-  : mWidth(0),
-    mHeight(0),
-    mRasterizeSuccess(true)
   {
   }
 
@@ -46,6 +49,7 @@ public:
 
   bool Load(const Vector<uint8_t>& data, float dpi)
   {
+    mLoadCount++;
     if(strncmp(reinterpret_cast<char*>(data.Begin()), "invalid", 7) == 0)
     {
       return false;
@@ -57,6 +61,11 @@ public:
     return true;
   }
 
+  bool IsLoaded() const
+  {
+    return mLoadCount > 0 ? true : false;
+  }
+
   Dali::Devel::PixelBuffer Rasterize(uint32_t width, uint32_t height)
   {
     if(mRasterizeSuccess)
@@ -74,9 +83,10 @@ public:
   }
 
 public:
-  uint32_t mWidth;
-  uint32_t mHeight;
-  bool     mRasterizeSuccess;
+  uint32_t mWidth{0};
+  uint32_t mHeight{0};
+  uint32_t mLoadCount{0};
+  bool     mRasterizeSuccess{true};
 };
 
 inline VectorImageRenderer& GetImplementation(Dali::VectorImageRenderer& renderer)
@@ -105,6 +115,8 @@ VectorImageRenderer VectorImageRenderer::New()
 {
   Internal::Adaptor::VectorImageRenderer* imageRenderer = new Internal::Adaptor::VectorImageRenderer();
 
+  Internal::Adaptor::gVectorImageRenderer = imageRenderer;
+
   return VectorImageRenderer(imageRenderer);
 }
 
@@ -126,6 +138,11 @@ bool VectorImageRenderer::Load(const Vector<uint8_t>& data, float dpi)
   return Internal::Adaptor::GetImplementation(*this).Load(data, dpi);
 }
 
+bool VectorImageRenderer::IsLoaded() const
+{
+  return Internal::Adaptor::GetImplementation(*this).IsLoaded();
+}
+
 Dali::Devel::PixelBuffer VectorImageRenderer::Rasterize(uint32_t width, uint32_t height)
 {
   return Internal::Adaptor::GetImplementation(*this).Rasterize(width, height);
@@ -137,3 +154,15 @@ void VectorImageRenderer::GetDefaultSize(uint32_t& width, uint32_t& height) cons
 }
 
 } // namespace Dali
+
+namespace Test
+{
+namespace VectorImageRenderer
+{
+uint32_t GetLoadCount()
+{
+  return Dali::Internal::Adaptor::gVectorImageRenderer->mLoadCount;
+}
+
+} // namespace VectorImageRenderer
+} // namespace Test
diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-vector-image-renderer.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-vector-image-renderer.h
new file mode 100644 (file)
index 0000000..37cc362
--- /dev/null
@@ -0,0 +1,30 @@
+#ifndef DALI_TOOLKIT_TEST_VECTOR_IMAGE_RENDERER_H
+#define DALI_TOOLKIT_TEST_VECTOR_IMAGE_RENDERER_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.
+ *
+ */
+
+namespace Test
+{
+namespace VectorImageRenderer
+{
+uint32_t GetLoadCount();
+
+} // namespace VectorImageRenderer
+} // namespace Test
+
+#endif // DALI_TOOLKIT_TEST_VECTOR_IMAGE_RENDERER_H
index 6745fea..3ae49cc 100644 (file)
@@ -73,7 +73,7 @@ static void TestKeyInputFocusCallback(Control control)
 
 const char* TEST_LARGE_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/tbcol.png";
 const char* TEST_IMAGE_FILE_NAME       = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
-const char* TEST_SVG_FILE_NAME         = TEST_RESOURCE_DIR "/Kid1.svg";
+const char* TEST_SVG_FILE_NAME         = TEST_RESOURCE_DIR "/svg1.svg";
 
 Vector4 GetControlBackgroundColor(Control& control)
 {
@@ -269,8 +269,8 @@ int UtcDaliControlNavigationProperties(void)
   DALI_TEST_EQUALS(-1, control.GetProperty(DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID).Get<int>(), TEST_LOCATION);
   DALI_TEST_EQUALS(-1, control.GetProperty(DevelControl::Property::UP_FOCUSABLE_ACTOR_ID).Get<int>(), TEST_LOCATION);
   DALI_TEST_EQUALS(-1, control.GetProperty(DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID).Get<int>(), TEST_LOCATION);
-  DALI_TEST_EQUALS(-1, control.GetProperty( DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID ).Get< int >(), TEST_LOCATION);
-  DALI_TEST_EQUALS(-1, control.GetProperty( DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID ).Get< int >(), TEST_LOCATION);
+  DALI_TEST_EQUALS(-1, control.GetProperty(DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID).Get<int>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(-1, control.GetProperty(DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID).Get<int>(), TEST_LOCATION);
 
   control.SetProperty(DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, 1);
   DALI_TEST_EQUALS(1, control.GetProperty(DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID).Get<int>(), TEST_LOCATION);
@@ -290,9 +290,9 @@ int UtcDaliControlNavigationProperties(void)
   control.SetProperty(DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, 18);
   DALI_TEST_EQUALS(18, control.GetProperty(DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID).Get<int>(), TEST_LOCATION);
   control.SetProperty(DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID, 19);
-  DALI_TEST_EQUALS(19, control.GetProperty( DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID ).Get< int >(), TEST_LOCATION);
+  DALI_TEST_EQUALS(19, control.GetProperty(DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID).Get<int>(), TEST_LOCATION);
   control.SetProperty(DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID, 20);
-  DALI_TEST_EQUALS(20, control.GetProperty( DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID ).Get< int >(), TEST_LOCATION);
+  DALI_TEST_EQUALS(20, control.GetProperty(DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID).Get<int>(), TEST_LOCATION);
 
   END_TEST;
 }
@@ -1074,6 +1074,9 @@ int UtcDaliControlResourcesReady02(void)
   application.SendNotification();
   application.Render();
 
+  // Wait for rasterization
+  DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
   DALI_TEST_EQUALS(control.IsResourceReady(), true, TEST_LOCATION);
   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
   gResourceReadySignalFired = false;
index 10d6445..edaeec1 100644 (file)
@@ -23,6 +23,7 @@
 
 #include <dali-toolkit-test-suite-utils.h>
 #include <toolkit-event-thread-callback.h>
+#include <toolkit-vector-image-renderer.h>
 #include "dummy-control.h"
 
 #include <test-encoded-image-buffer.h>
@@ -2727,12 +2728,7 @@ int UtcDaliImageViewSyncSVGLoading(void)
 
   tet_infoline("ImageView Testing SVG image sync loading");
 
-  // Sync loading, automatic atlasing for small size image
   {
-    TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
-    callStack.Reset();
-    callStack.Enable(true);
-
     ImageView imageView = ImageView::New();
 
     // Sync loading is used
@@ -2746,7 +2742,6 @@ int UtcDaliImageViewSyncSVGLoading(void)
     DALI_TEST_CHECK(imageView);
 
     application.SendNotification();
-    application.Render(16);
     Vector3 naturalSize = imageView.GetNaturalSize();
 
     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
@@ -2761,28 +2756,27 @@ int UtcDaliImageViewAsyncSVGLoading(void)
 
   tet_infoline("ImageView Testing SVG image async loading");
 
-  // Sync loading, automatic atlasing for small size image
   {
-    TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
-    callStack.Reset();
-    callStack.Enable(true);
-
     ImageView imageView = ImageView::New();
 
-    // Sync loading is used
-    Property::Map syncLoadingMap;
-    syncLoadingMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
-    syncLoadingMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
-    syncLoadingMap.Insert(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, false);
-    imageView.SetProperty(ImageView::Property::IMAGE, syncLoadingMap);
+    // Async loading is used - default value of SYNCHRONOUS_LOADING is false.
+    Property::Map propertyMap;
+    propertyMap.Insert(Toolkit::Visual::Property::TYPE, Toolkit::Visual::IMAGE);
+    propertyMap.Insert(Toolkit::ImageVisual::Property::URL, TEST_RESOURCE_DIR "/svg1.svg");
+    imageView.SetProperty(ImageView::Property::IMAGE, propertyMap);
 
     application.GetScene().Add(imageView);
     DALI_TEST_CHECK(imageView);
 
     application.SendNotification();
+
+    // Wait for rasterization
+    DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
+    application.SendNotification();
     application.Render(16);
-    Vector3 naturalSize = imageView.GetNaturalSize();
 
+    Vector3 naturalSize = imageView.GetNaturalSize();
     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
   }
@@ -2795,12 +2789,8 @@ int UtcDaliImageViewSVGLoadingSyncSetInvalidValue(void)
 
   tet_infoline("ImageView Testing SVG image async loading");
 
-  // Sync loading, automatic atlasing for small size image
+  // Sync loading
   {
-    TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
-    callStack.Reset();
-    callStack.Enable(true);
-
     ImageView imageView = ImageView::New();
 
     // Sync loading is used
@@ -2819,7 +2809,13 @@ int UtcDaliImageViewSVGLoadingSyncSetInvalidValue(void)
     DALI_TEST_CHECK(imageView);
 
     application.SendNotification();
+
+    // Wait for rasterization
+    DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
+    application.SendNotification();
     application.Render(16);
+
     Vector3 naturalSize = imageView.GetNaturalSize();
     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
     DALI_TEST_EQUALS(naturalSize.height, 100.0f, TEST_LOCATION);
@@ -2856,6 +2852,11 @@ int UtcDaliImageViewSvgLoadingFailure(void)
     application.GetScene().Add(imageView);
 
     application.SendNotification();
+
+    // loading started, this waits for the loader thread
+    DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
+    application.SendNotification();
     application.Render(16);
 
     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
@@ -2880,6 +2881,11 @@ int UtcDaliImageViewSvgLoadingFailure(void)
     application.GetScene().Add(imageView);
 
     application.SendNotification();
+
+    // loading started, this waits for the loader thread
+    DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
+    application.SendNotification();
     application.Render(16);
 
     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
@@ -2905,6 +2911,11 @@ int UtcDaliImageViewSvgLoadingFailure(void)
     application.GetScene().Add(imageView);
 
     application.SendNotification();
+
+    // loading started, this waits for the loader thread
+    DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
+    application.SendNotification();
     application.Render(16);
 
     DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
@@ -3015,6 +3026,44 @@ int UtcDaliImageViewSvgRasterizationFailure(void)
   END_TEST;
 }
 
+int UtcDaliImageViewSvgChageSize(void)
+{
+  ToolkitTestApplication application;
+
+  TestGlAbstraction& gl           = application.GetGlAbstraction();
+  TraceCallStack&    textureTrace = gl.GetTextureTrace();
+  textureTrace.Enable(true);
+
+  ImageView imageView = ImageView::New(TEST_SVG_FILE_NAME);
+  application.GetScene().Add(imageView);
+
+  application.SendNotification();
+
+  // loading started, this waits for the loader thread
+  DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
+  application.SendNotification();
+  application.Render(16);
+
+  DALI_TEST_EQUALS(Test::VectorImageRenderer::GetLoadCount(), 1, TEST_LOCATION);
+
+  // Change actor size, then rasterization should be done again
+  imageView.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
+
+  application.SendNotification();
+
+  // loading started, this waits for the loader thread
+  DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
+  application.SendNotification();
+  application.Render(16);
+
+  // We should not load the file again.
+  DALI_TEST_EQUALS(Test::VectorImageRenderer::GetLoadCount(), 1, TEST_LOCATION);
+
+  END_TEST;
+}
+
 int UtcDaliImageViewTVGLoading(void)
 {
   ToolkitTestApplication application;
@@ -3022,12 +3071,17 @@ int UtcDaliImageViewTVGLoading(void)
   tet_infoline("ImageView Testing TVG image loading");
 
   {
-    ImageView imageView = ImageView::New();
-
-    imageView.SetImage(TEST_RESOURCE_DIR "/test.tvg");
-
+    ImageView imageView = ImageView::New(TEST_RESOURCE_DIR "/test.tvg");
     application.GetScene().Add(imageView);
     DALI_TEST_CHECK(imageView);
+
+    application.SendNotification();
+
+    DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
+
+    application.SendNotification();
+    application.Render(16);
+
     Vector3 naturalSize = imageView.GetNaturalSize();
 
     DALI_TEST_EQUALS(naturalSize.width, 100.0f, TEST_LOCATION);
@@ -3603,7 +3657,7 @@ int UtcDaliImageViewCheckVariousCaseSendOnResourceReadySignal(void)
 
   // Test broken case
   TestResourceReadyUrl(1, 0, 0, "invalid.jpg", "", TEST_LOCATION);
-  TestResourceReadyUrl(0, 0, 0, "invalid.svg", "", TEST_LOCATION); // 0 rasterize
+  TestResourceReadyUrl(1, 0, 0, "invalid.svg", "", TEST_LOCATION);
   TestResourceReadyUrl(1, 0, 0, "invalid.9.png", "", TEST_LOCATION);
   TestResourceReadyUrl(1, 0, 0, "invalid.gif", "", TEST_LOCATION);  // 1 image loading
   TestResourceReadyUrl(0, 0, 0, "invalid.json", "", TEST_LOCATION); // 0 rasterize
@@ -3633,7 +3687,7 @@ int UtcDaliImageViewCheckVariousCaseSendOnResourceReadySignal(void)
 
   // Test broken case
   TestResourceReadyUrl(0, 1, 0, "invalid.jpg", "", TEST_LOCATION);
-  TestResourceReadyUrl(0, 1, 0, "invalid.svg", "", TEST_LOCATION); // 0 rasterize
+  TestResourceReadyUrl(0, 1, 0, "invalid.svg", "", TEST_LOCATION);
   TestResourceReadyUrl(0, 1, 0, "invalid.9.png", "", TEST_LOCATION);
   TestResourceReadyUrl(0, 1, 0, "invalid.gif", "", TEST_LOCATION);
   TestResourceReadyUrl(0, 1, 0, "invalid.json", "", TEST_LOCATION); // 0 rasterize
index c810939..dab40a2 100644 (file)
@@ -644,6 +644,21 @@ int UtcDaliToolkitTextLabelSetPropertyP(void)
   DALI_TEST_EQUALS(strikethroughMapGet.Count(), strikethroughMapSet.Count(), TEST_LOCATION);
   DALI_TEST_EQUALS(DaliTestCheckMaps(strikethroughMapGet, strikethroughMapSet), true, TEST_LOCATION);
 
+  // Check the transparent strikethrough property for coverage.
+  strikethroughMapSet.Clear();
+  strikethroughMapSet.Insert("enable", true);
+  strikethroughMapSet.Insert("color", Color::TRANSPARENT);
+  strikethroughMapSet.Insert("height", 2.0f);
+
+  label.SetProperty(DevelTextLabel::Property::STRIKETHROUGH, strikethroughMapSet);
+
+  application.SendNotification();
+  application.Render();
+
+  strikethroughMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::STRIKETHROUGH);
+  DALI_TEST_EQUALS(strikethroughMapGet.Count(), strikethroughMapSet.Count(), TEST_LOCATION);
+  DALI_TEST_EQUALS(DaliTestCheckMaps(strikethroughMapGet, strikethroughMapSet), true, TEST_LOCATION);
+
   strikethroughMapSet.Clear();
   strikethroughMapSet.Insert(Toolkit::DevelText::Strikethrough::Property::ENABLE, true);
   strikethroughMapSet.Insert(Toolkit::DevelText::Strikethrough::Property::COLOR, Color::RED);
@@ -803,6 +818,24 @@ int UtcDaliToolkitTextLabelSetPropertyP(void)
   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
 
+  // Check the transparent double underline property for coverage.
+  underlineMapSet.Clear();
+  underlineMapSet.Insert("enable", true);
+  underlineMapSet.Insert("color", Color::TRANSPARENT);
+  underlineMapSet.Insert("height", 1);
+  underlineMapSet.Insert("type", Text::Underline::DOUBLE);
+  underlineMapSet.Insert("dashWidth", 2);
+  underlineMapSet.Insert("dashGap", 1);
+
+  label.SetProperty(TextLabel::Property::UNDERLINE, underlineMapSet);
+
+  application.SendNotification();
+  application.Render();
+
+  underlineMapGet = label.GetProperty<Property::Map>(TextLabel::Property::UNDERLINE);
+  DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
+  DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
+
   underlineMapSet.Clear();
   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::ENABLE, true);
   underlineMapSet.Insert(Toolkit::DevelText::Underline::Property::COLOR, Color::GREEN);
@@ -931,6 +964,19 @@ int UtcDaliToolkitTextLabelSetPropertyP(void)
   DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
   DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
 
+  // Check the transparent background property for coverage
+  backgroundMapSet.Clear();
+  backgroundMapSet["enable"] = true;
+  backgroundMapSet["color"]  = Color::TRANSPARENT;
+  label.SetProperty(DevelTextLabel::Property::BACKGROUND, backgroundMapSet);
+
+  application.SendNotification();
+  application.Render();
+
+  backgroundMapGet = label.GetProperty<Property::Map>(DevelTextLabel::Property::BACKGROUND);
+  DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
+  DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
+
   backgroundMapSet.Clear();
   backgroundMapSet[Toolkit::DevelText::Background::Property::ENABLE] = true;
   backgroundMapSet[Toolkit::DevelText::Background::Property::COLOR]  = Color::GREEN;
index c17567a..bd3469a 100644 (file)
@@ -325,7 +325,6 @@ int UtcDaliVisualSize(void)
   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 
   // animated gradient visual
-  Vector2 animated_gradient_visual_size(10.f, 10.f);
   propertyMap.Clear();
   propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
@@ -333,20 +332,6 @@ int UtcDaliVisualSize(void)
   animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
 
-  // svg visual
-  Visual::Base svgVisual = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
-  svgVisual.GetNaturalSize(naturalSize);
-  // TEST_SVG_FILE:
-  //  <svg width="100" height="100">
-  //  <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
-  //  </svg>
-  DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION);
-
-  // svg visual with a size
-  Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions(200, 200));
-  svgVisual2.GetNaturalSize(naturalSize);
-  DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 100.f), TEST_LOCATION); // Natural size should still be 100, 100
-
   // Text visual.
 
   // Load some fonts to get the same metrics on different platforms.
index 8f927f5..3c295e3 100644 (file)
@@ -1,3 +1,5 @@
+#version 300 es
+
 // Original Code
 // https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/glTF-WebGL-PBR/shaders/pbr-frag.glsl
 // Commit dc84b5e374fb3d23153d2248a338ef88173f9eb6
@@ -15,8 +17,6 @@
 // [4] \"An Inexpensive BRDF Model for Physically based Rendering\" by Christophe Schlick
 //     https://www.cs.virginia.edu/~jdl/bib/appearance/analytic%20models/schlick94b.pdf
 
-#version 300 es
-
 #ifdef HIGHP
 precision highp float;
 #else
index a4451e5..2bae244 100644 (file)
@@ -1,9 +1,9 @@
+#version 300 es
+
 // Original Code
 // https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/glTF-WebGL-PBR/shaders/pbr-vert.glsl
 // Commit dc84b5e374fb3d23153d2248a338ef88173f9eb6
 
-#version 300 es
-
 #ifdef HIGHP
   precision highp float;
 #else
@@ -58,7 +58,7 @@ uniform int uBlendShapeComponentSize;                               ///< The siz
 
 void main()
 {
-  vec4 position = vec4(aPosition, 1.0);
+  highp vec4 position = vec4(aPosition, 1.0);
   vec3 normal = aNormal;
   vec3 tangent = aTangent.xyz;
 
@@ -130,7 +130,7 @@ void main()
 #endif
 
 #ifdef SKINNING
-  mat4 bone = uBone[int(aJoints.x)] * aWeights.x +
+  highp mat4 bone = uBone[int(aJoints.x)] * aWeights.x +
     uBone[int(aJoints.y)] * aWeights.y +
     uBone[int(aJoints.z)] * aWeights.z +
     uBone[int(aJoints.w)] * aWeights.w;
@@ -139,12 +139,12 @@ void main()
   tangent = (bone * vec4(tangent, 0.0)).xyz;
 #endif
 
-  vec4 positionW = uModelMatrix * position;
-  vec4 positionV = uViewMatrix * positionW;
+  highp vec4 positionW = uModelMatrix * position;
+  highp vec4 positionV = uViewMatrix * positionW;
 
   vPositionToCamera = transpose(mat3(uViewMatrix)) * -vec3(positionV.xyz / positionV.w);
 
-  lowp vec3 bitangent = cross(normal, tangent);
+  vec3 bitangent = cross(normal, tangent);
 #ifdef VEC4_TANGENT
   bitangent *= aTangent.w;
 #endif
index 500a081..826e894 100644 (file)
@@ -41,6 +41,20 @@ namespace
 {
 const float HALF(0.5f);
 const float ONE_AND_A_HALF(1.5f);
+
+/**
+ * @brief Fast multiply & divide by 255. It wiil be useful when we applying alpha value in color
+ *
+ * @param x The value between [0..255]
+ * @param y The value between [0..255]
+ * @return (x*y)/255
+ */
+inline uint8_t MultiplyAndNormalizeColor(const uint8_t& x, const uint8_t& y) noexcept
+{
+  const uint32_t xy = static_cast<const uint32_t>(x) * y;
+  return ((xy << 15) + (xy << 7) + xy) >> 23;
+}
+
 /**
  * @brief Data struct used to set the buffer of the glyph's bitmap into the final bitmap's buffer.
  */
@@ -49,16 +63,16 @@ struct GlyphData
   Devel::PixelBuffer                           bitmapBuffer;     ///< The buffer of the whole bitmap. The format is RGBA8888.
   Vector2*                                     position;         ///< The position of the glyph.
   TextAbstraction::FontClient::GlyphBufferData glyphBitmap;      ///< The glyph's bitmap.
-  unsigned int                                 width;            ///< The bitmap's width.
-  unsigned int                                 height;           ///< The bitmap's height.
-  int                                          horizontalOffset; ///< The horizontal offset to be added to the 'x' glyph's position.
-  int                                          verticalOffset;   ///< The vertical offset to be added to the 'y' glyph's position.
+  uint32_t                                     width;            ///< The bitmap's width.
+  uint32_t                                     height;           ///< The bitmap's height.
+  int32_t                                      horizontalOffset; ///< The horizontal offset to be added to the 'x' glyph's position.
+  int32_t                                      verticalOffset;   ///< The vertical offset to be added to the 'y' glyph's position.
 };
 
 /**
  * @brief Sets the glyph's buffer into the bitmap's buffer.
  *
- * @param[in] data Struct which contains the glyph's data and the bitmap's data.
+ * @param[in, out] data Struct which contains the glyph's data and the bitmap's data.
  * @param[in] position The position of the glyph.
  * @param[in] color The color of the glyph.
  * @param[in] style The style of the text.
@@ -76,46 +90,70 @@ void TypesetGlyph(GlyphData&           data,
     return;
   }
 
-  const int widthMinusOne  = static_cast<int>(data.width - 1u);
-  const int heightMinusOne = static_cast<int>(data.height - 1u);
+  // Initial vertical / horizontal offset.
+  const int32_t yOffset = data.verticalOffset + position->y;
+  const int32_t xOffset = data.horizontalOffset + position->x;
+
+  // Whether the given glyph is a color one.
+  const bool     isColorGlyph   = data.glyphBitmap.isColorEmoji || data.glyphBitmap.isColorBitmap;
+  const uint32_t glyphPixelSize = Pixel::GetBytesPerPixel(data.glyphBitmap.format);
+  const uint32_t alphaIndex     = glyphPixelSize - 1u;
+
+  // Determinate iterator range.
+  const int32_t lineIndexRangeMin = std::max(0, -yOffset);
+  const int32_t lineIndexRangeMax = std::min(static_cast<int32_t>(data.glyphBitmap.height), static_cast<int32_t>(data.height) - yOffset);
+  const int32_t indexRangeMin     = std::max(0, -xOffset);
+  const int32_t indexRangeMax     = std::min(static_cast<int32_t>(data.glyphBitmap.width), static_cast<int32_t>(data.width) - xOffset);
+
+  // If current glyph don't need to be rendered, just ignore.
+  if(lineIndexRangeMax <= lineIndexRangeMin || indexRangeMax <= indexRangeMin)
+  {
+    return;
+  }
 
   if(Pixel::RGBA8888 == pixelFormat)
   {
-    // Whether the given glyph is a color one.
-    const bool     isColorGlyph   = data.glyphBitmap.isColorEmoji || data.glyphBitmap.isColorBitmap;
-    const uint32_t glyphPixelSize = Pixel::GetBytesPerPixel(data.glyphBitmap.format);
-    const uint32_t alphaIndex     = glyphPixelSize - 1u;
-    const bool     swapChannelsBR = Pixel::BGRA8888 == data.glyphBitmap.format;
+    const bool swapChannelsBR = Pixel::BGRA8888 == data.glyphBitmap.format;
+
+    uint32_t* bitmapBuffer = reinterpret_cast<uint32_t*>(data.bitmapBuffer.GetBuffer());
+
+    // Fast-cut if style is MASK or OUTLINE. Outline not shown for color glyph.
+    // Just overwrite transparent color and return.
+    if(isColorGlyph && (Typesetter::STYLE_MASK == style || Typesetter::STYLE_OUTLINE == style))
+    {
+      for(int32_t lineIndex = lineIndexRangeMin; lineIndex < lineIndexRangeMax; ++lineIndex)
+      {
+        const int32_t yOffsetIndex   = yOffset + lineIndex;
+        const int32_t verticalOffset = yOffsetIndex * data.width;
+
+        // We can use memset here.
+        memset(bitmapBuffer + verticalOffset + xOffset + indexRangeMin, 0, (indexRangeMax - indexRangeMin) * sizeof(uint32_t));
+      }
+      return;
+    }
 
     // Pointer to the color glyph if there is one.
     const uint32_t* const colorGlyphBuffer = isColorGlyph ? reinterpret_cast<uint32_t*>(data.glyphBitmap.buffer) : NULL;
 
-    // Initial vertical offset.
-    const int yOffset = data.verticalOffset + position->y;
+    // Precalculate input color's packed result.
+    uint32_t packedInputColor       = 0u;
+    uint8_t* packedInputColorBuffer = reinterpret_cast<uint8_t*>(&packedInputColor);
 
-    uint32_t* bitmapBuffer = reinterpret_cast<uint32_t*>(data.bitmapBuffer.GetBuffer());
+    *(packedInputColorBuffer + 3u) = static_cast<uint8_t>(color->a * 255);
+    *(packedInputColorBuffer + 2u) = static_cast<uint8_t>(color->b * 255);
+    *(packedInputColorBuffer + 1u) = static_cast<uint8_t>(color->g * 255);
+    *(packedInputColorBuffer)      = static_cast<uint8_t>(color->r * 255);
 
     // Traverse the pixels of the glyph line per line.
-    for(int lineIndex = 0, glyphHeight = static_cast<int>(data.glyphBitmap.height); lineIndex < glyphHeight; ++lineIndex)
+    for(int32_t lineIndex = lineIndexRangeMin; lineIndex < lineIndexRangeMax; ++lineIndex)
     {
-      const int yOffsetIndex = yOffset + lineIndex;
-      if((0 > yOffsetIndex) || (yOffsetIndex > heightMinusOne))
-      {
-        // Do not write out of bounds.
-        continue;
-      }
+      const int32_t yOffsetIndex = yOffset + lineIndex;
 
-      const int verticalOffset    = yOffsetIndex * data.width;
-      const int xOffset           = data.horizontalOffset + position->x;
-      const int glyphBufferOffset = lineIndex * static_cast<int>(data.glyphBitmap.width);
-      for(int index = 0, glyphWidth = static_cast<int>(data.glyphBitmap.width); index < glyphWidth; ++index)
+      const int32_t verticalOffset    = yOffsetIndex * data.width;
+      const int32_t glyphBufferOffset = lineIndex * static_cast<int32_t>(data.glyphBitmap.width);
+      for(int32_t index = indexRangeMin; index < indexRangeMax; ++index)
       {
-        const int xOffsetIndex = xOffset + index;
-        if((0 > xOffsetIndex) || (xOffsetIndex > widthMinusOne))
-        {
-          // Don't write out of bounds.
-          continue;
-        }
+        const int32_t xOffsetIndex = xOffset + index;
 
         if(isColorGlyph)
         {
@@ -124,43 +162,32 @@ void TypesetGlyph(GlyphData&           data,
           uint8_t* packedColorGlyphBuffer = reinterpret_cast<uint8_t*>(&packedColorGlyph);
 
           // Update the alpha channel.
-          if(Typesetter::STYLE_MASK == style || Typesetter::STYLE_OUTLINE == style) // Outline not shown for color glyph
+          const uint8_t colorAlpha       = MultiplyAndNormalizeColor(*(packedInputColorBuffer + 3u), *(packedColorGlyphBuffer + 3u));
+          *(packedColorGlyphBuffer + 3u) = colorAlpha;
+
+          if(Typesetter::STYLE_SHADOW == style)
           {
-            // Create an alpha mask for color glyph.
-            *(packedColorGlyphBuffer + 3u) = 0u;
-            *(packedColorGlyphBuffer + 2u) = 0u;
-            *(packedColorGlyphBuffer + 1u) = 0u;
-            *packedColorGlyphBuffer        = 0u;
+            // The shadow of color glyph needs to have the shadow color.
+            *(packedColorGlyphBuffer + 2u) = MultiplyAndNormalizeColor(*(packedInputColorBuffer + 2u), colorAlpha);
+            *(packedColorGlyphBuffer + 1u) = MultiplyAndNormalizeColor(*(packedInputColorBuffer + 1u), colorAlpha);
+            *packedColorGlyphBuffer        = MultiplyAndNormalizeColor(*packedInputColorBuffer, colorAlpha);
           }
           else
           {
-            const uint8_t colorAlpha       = static_cast<uint8_t>(color->a * static_cast<float>(*(packedColorGlyphBuffer + 3u)));
-            *(packedColorGlyphBuffer + 3u) = colorAlpha;
-
-            if(Typesetter::STYLE_SHADOW == style)
+            if(swapChannelsBR)
             {
-              // The shadow of color glyph needs to have the shadow color.
-              *(packedColorGlyphBuffer + 2u) = static_cast<uint8_t>(color->b * colorAlpha);
-              *(packedColorGlyphBuffer + 1u) = static_cast<uint8_t>(color->g * colorAlpha);
-              *packedColorGlyphBuffer        = static_cast<uint8_t>(color->r * colorAlpha);
+              std::swap(*packedColorGlyphBuffer, *(packedColorGlyphBuffer + 2u)); // Swap B and R.
             }
-            else
+
+            *(packedColorGlyphBuffer + 2u) = MultiplyAndNormalizeColor(*(packedColorGlyphBuffer + 2u), colorAlpha);
+            *(packedColorGlyphBuffer + 1u) = MultiplyAndNormalizeColor(*(packedColorGlyphBuffer + 1u), colorAlpha);
+            *packedColorGlyphBuffer        = MultiplyAndNormalizeColor(*packedColorGlyphBuffer, colorAlpha);
+
+            if(data.glyphBitmap.isColorBitmap)
             {
-              if(swapChannelsBR)
-              {
-                std::swap(*packedColorGlyphBuffer, *(packedColorGlyphBuffer + 2u)); // Swap B and R.
-              }
-
-              *(packedColorGlyphBuffer + 2u) = (*(packedColorGlyphBuffer + 2u) * colorAlpha / 255);
-              *(packedColorGlyphBuffer + 1u) = (*(packedColorGlyphBuffer + 1u) * colorAlpha / 255);
-              *packedColorGlyphBuffer        = (*(packedColorGlyphBuffer)*colorAlpha / 255);
-
-              if(data.glyphBitmap.isColorBitmap)
-              {
-                *(packedColorGlyphBuffer + 2u) = static_cast<uint8_t>(*(packedColorGlyphBuffer + 2u) * color->b);
-                *(packedColorGlyphBuffer + 1u) = static_cast<uint8_t>(*(packedColorGlyphBuffer + 1u) * color->g);
-                *packedColorGlyphBuffer        = static_cast<uint8_t>(*packedColorGlyphBuffer * color->r);
-              }
+              *(packedColorGlyphBuffer + 2u) = MultiplyAndNormalizeColor(*(packedInputColorBuffer + 2u), *(packedColorGlyphBuffer + 2u));
+              *(packedColorGlyphBuffer + 1u) = MultiplyAndNormalizeColor(*(packedInputColorBuffer + 1u), *(packedColorGlyphBuffer + 1u));
+              *packedColorGlyphBuffer        = MultiplyAndNormalizeColor(*packedInputColorBuffer, *packedColorGlyphBuffer);
             }
           }
 
@@ -190,15 +217,22 @@ void TypesetGlyph(GlyphData&           data,
             // happen, for example, in the RTL text when we copy glyphs from right to left).
             uint8_t currentAlpha = *(packedCurrentColorBuffer + 3u);
             currentAlpha         = std::max(currentAlpha, alpha);
-
-            // Color is pre-muliplied with its alpha.
-            *(packedColorBuffer + 3u) = static_cast<uint8_t>(color->a * currentAlpha);
-            *(packedColorBuffer + 2u) = static_cast<uint8_t>(color->b * currentAlpha);
-            *(packedColorBuffer + 1u) = static_cast<uint8_t>(color->g * currentAlpha);
-            *(packedColorBuffer)      = static_cast<uint8_t>(color->r * currentAlpha);
-
-            // Set the color into the final pixel buffer.
-            currentColor = packedColor;
+            if(currentAlpha == 255)
+            {
+              // Fast-cut to avoid float type operation.
+              currentColor = packedInputColor;
+            }
+            else
+            {
+              // Color is pre-muliplied with its alpha.
+              *(packedColorBuffer + 3u) = MultiplyAndNormalizeColor(*(packedInputColorBuffer + 3u), currentAlpha);
+              *(packedColorBuffer + 2u) = MultiplyAndNormalizeColor(*(packedInputColorBuffer + 2u), currentAlpha);
+              *(packedColorBuffer + 1u) = MultiplyAndNormalizeColor(*(packedInputColorBuffer + 1u), currentAlpha);
+              *(packedColorBuffer)      = MultiplyAndNormalizeColor(*packedInputColorBuffer, currentAlpha);
+
+              // Set the color into the final pixel buffer.
+              currentColor = packedColor;
+            }
           }
         }
       }
@@ -206,40 +240,22 @@ void TypesetGlyph(GlyphData&           data,
   }
   else
   {
-    // Whether the given glyph is a color one.
-    const bool     isColorGlyph   = data.glyphBitmap.isColorEmoji || data.glyphBitmap.isColorBitmap;
-    const uint32_t glyphPixelSize = Pixel::GetBytesPerPixel(data.glyphBitmap.format);
-    const uint32_t alphaIndex     = glyphPixelSize - 1u;
-
-    // Initial vertical offset.
-    const int yOffset = data.verticalOffset + position->y;
-
-    uint8_t* bitmapBuffer = reinterpret_cast<uint8_t*>(data.bitmapBuffer.GetBuffer());
-
-    // Traverse the pixels of the glyph line per line.
-    for(int lineIndex = 0, glyphHeight = static_cast<int>(data.glyphBitmap.height); lineIndex < glyphHeight; ++lineIndex)
+    // Below codes required only if not color glyph.
+    if(!isColorGlyph)
     {
-      const int yOffsetIndex = yOffset + lineIndex;
-      if((0 > yOffsetIndex) || (yOffsetIndex > heightMinusOne))
-      {
-        // Do not write out of bounds.
-        continue;
-      }
+      uint8_t* bitmapBuffer = reinterpret_cast<uint8_t*>(data.bitmapBuffer.GetBuffer());
 
-      const int verticalOffset    = yOffsetIndex * data.width;
-      const int xOffset           = data.horizontalOffset + position->x;
-      const int glyphBufferOffset = lineIndex * static_cast<int>(data.glyphBitmap.width);
-      for(int index = 0, glyphWidth = static_cast<int>(data.glyphBitmap.width); index < glyphWidth; ++index)
+      // Traverse the pixels of the glyph line per line.
+      for(int32_t lineIndex = lineIndexRangeMin; lineIndex < lineIndexRangeMax; ++lineIndex)
       {
-        const int xOffsetIndex = xOffset + index;
-        if((0 > xOffsetIndex) || (xOffsetIndex > widthMinusOne))
-        {
-          // Don't write out of bounds.
-          continue;
-        }
+        const int32_t yOffsetIndex = yOffset + lineIndex;
 
-        if(!isColorGlyph)
+        const int32_t verticalOffset    = yOffsetIndex * data.width;
+        const int32_t glyphBufferOffset = lineIndex * static_cast<int32_t>(data.glyphBitmap.width);
+        for(int32_t index = indexRangeMin; index < indexRangeMax; ++index)
         {
+          const int32_t xOffsetIndex = xOffset + index;
+
           // Update the alpha channel.
           const uint8_t alpha = *(data.glyphBitmap.buffer + glyphPixelSize * (glyphBufferOffset + index) + alphaIndex);
 
@@ -261,38 +277,16 @@ void TypesetGlyph(GlyphData&           data,
   }
 }
 
-/// Draws the specified color to the pixel buffer
-void WriteColorToPixelBuffer(
-  GlyphData&         glyphData,
-  uint32_t*          bitmapBuffer,
-  const Vector4&     color,
-  const unsigned int x,
-  const unsigned int y)
-{
-  // Always RGBA image for text with styles
-  uint32_t pixel       = *(bitmapBuffer + y * glyphData.width + x);
-  uint8_t* pixelBuffer = reinterpret_cast<uint8_t*>(&pixel);
-
-  // Write the color to the pixel buffer
-  uint8_t colorAlpha  = static_cast<uint8_t>(color.a * 255.f);
-  *(pixelBuffer + 3u) = colorAlpha;
-  *(pixelBuffer + 2u) = static_cast<uint8_t>(color.b * colorAlpha);
-  *(pixelBuffer + 1u) = static_cast<uint8_t>(color.g * colorAlpha);
-  *(pixelBuffer)      = static_cast<uint8_t>(color.r * colorAlpha);
-
-  *(bitmapBuffer + y * glyphData.width + x) = pixel;
-}
-
 /// Draws the specified underline color to the buffer
 void DrawUnderline(
-  const unsigned int              bufferWidth,
-  const unsigned int              bufferHeight,
+  const uint32_t&                 bufferWidth,
+  const uint32_t&                 bufferHeight,
   GlyphData&                      glyphData,
-  const float                     baseline,
-  const float                     currentUnderlinePosition,
-  const float                     maxUnderlineHeight,
-  const float                     lineExtentLeft,
-  const float                     lineExtentRight,
+  const float&                    baseline,
+  const float&                    currentUnderlinePosition,
+  const float&                    maxUnderlineHeight,
+  const float&                    lineExtentLeft,
+  const float&                    lineExtentRight,
   const UnderlineStyleProperties& commonUnderlineProperties,
   const UnderlineStyleProperties& currentUnderlineProperties,
   const LineRun&                  line)
@@ -302,76 +296,118 @@ void DrawUnderline(
   const float                 dashedUnderlineWidth = currentUnderlineProperties.dashWidthDefined ? currentUnderlineProperties.dashWidth : commonUnderlineProperties.dashWidth;
   const float                 dashedUnderlineGap   = currentUnderlineProperties.dashGapDefined ? currentUnderlineProperties.dashGap : commonUnderlineProperties.dashGap;
 
-  int       underlineYOffset = glyphData.verticalOffset + baseline + currentUnderlinePosition;
-  uint32_t* bitmapBuffer     = reinterpret_cast<uint32_t*>(glyphData.bitmapBuffer.GetBuffer());
+  int32_t underlineYOffset = glyphData.verticalOffset + baseline + currentUnderlinePosition;
+
+  const uint32_t yRangeMin = underlineYOffset;
+  const uint32_t yRangeMax = std::min(bufferHeight, underlineYOffset + static_cast<uint32_t>(maxUnderlineHeight));
+  const uint32_t xRangeMin = static_cast<uint32_t>(glyphData.horizontalOffset + lineExtentLeft);
+  const uint32_t xRangeMax = std::min(bufferWidth, static_cast<uint32_t>(glyphData.horizontalOffset + lineExtentRight + 1)); // Due to include last point, we add 1 here
+
+  // If current glyph don't need to be rendered, just ignore.
+  if((underlineType != Text::Underline::DOUBLE && yRangeMax <= yRangeMin) || xRangeMax <= xRangeMin)
+  {
+    return;
+  }
+
+  // We can optimize by memset when underlineColor.a is near zero
+  uint8_t underlineColorAlpha = static_cast<uint8_t>(underlineColor.a * 255.f);
 
-  for(unsigned int y = underlineYOffset; y < underlineYOffset + maxUnderlineHeight; y++)
+  uint32_t* bitmapBuffer = reinterpret_cast<uint32_t*>(glyphData.bitmapBuffer.GetBuffer());
+
+  // Skip yRangeMin line.
+  bitmapBuffer += yRangeMin * glyphData.width;
+
+  // Note if underlineType is DASHED, we cannot setup color by memset.
+  if(underlineType != Text::Underline::DASHED && underlineColorAlpha == 0)
   {
-    if(y > bufferHeight - 1)
+    for(uint32_t y = yRangeMin; y < yRangeMax; y++)
     {
-      // Do not write out of bounds.
-      break;
+      // We can use memset.
+      memset(bitmapBuffer + xRangeMin, 0, (xRangeMax - xRangeMin) * sizeof(uint32_t));
+      bitmapBuffer += glyphData.width;
     }
-    if(underlineType == Text::Underline::DASHED)
+    if(underlineType == Text::Underline::DOUBLE)
     {
-      float dashWidth = dashedUnderlineWidth;
-      float dashGap   = 0;
+      int32_t        secondUnderlineYOffset = underlineYOffset - ONE_AND_A_HALF * maxUnderlineHeight;
+      const uint32_t secondYRangeMin        = static_cast<uint32_t>(std::max(0, secondUnderlineYOffset));
+      const uint32_t secondYRangeMax        = static_cast<uint32_t>(std::max(0, std::min(static_cast<int32_t>(bufferHeight), secondUnderlineYOffset + static_cast<int32_t>(maxUnderlineHeight))));
 
-      for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++)
+      // Rewind bitmapBuffer pointer, and skip secondYRangeMin line.
+      bitmapBuffer = reinterpret_cast<uint32_t*>(glyphData.bitmapBuffer.GetBuffer()) + yRangeMin * glyphData.width;
+
+      for(uint32_t y = secondYRangeMin; y < secondYRangeMax; y++)
       {
-        if(x > bufferWidth - 1)
-        {
-          // Do not write out of bounds.
-          break;
-        }
-        if(dashGap == 0 && dashWidth > 0)
-        {
-          WriteColorToPixelBuffer(glyphData, bitmapBuffer, underlineColor, x, y);
-          dashWidth--;
-        }
-        else if(dashGap < dashedUnderlineGap)
-        {
-          dashGap++;
-        }
-        else
-        {
-          //reset
-          dashWidth = dashedUnderlineWidth;
-          dashGap   = 0;
-        }
+        // We can use memset.
+        memset(bitmapBuffer + xRangeMin, 0, (xRangeMax - xRangeMin) * sizeof(uint32_t));
+        bitmapBuffer += glyphData.width;
       }
     }
-    else
+  }
+  else
+  {
+    uint32_t packedUnderlineColor       = 0u;
+    uint8_t* packedUnderlineColorBuffer = reinterpret_cast<uint8_t*>(&packedUnderlineColor);
+
+    // Write the color to the pixel buffer
+    *(packedUnderlineColorBuffer + 3u) = underlineColorAlpha;
+    *(packedUnderlineColorBuffer + 2u) = static_cast<uint8_t>(underlineColor.b * underlineColorAlpha);
+    *(packedUnderlineColorBuffer + 1u) = static_cast<uint8_t>(underlineColor.g * underlineColorAlpha);
+    *(packedUnderlineColorBuffer)      = static_cast<uint8_t>(underlineColor.r * underlineColorAlpha);
+
+    for(uint32_t y = yRangeMin; y < yRangeMax; y++)
     {
-      for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++)
+      if(underlineType == Text::Underline::DASHED)
       {
-        if(x > bufferWidth - 1)
+        float dashWidth = dashedUnderlineWidth;
+        float dashGap   = 0;
+
+        for(uint32_t x = xRangeMin; x < xRangeMax; x++)
         {
-          // Do not write out of bounds.
-          break;
+          if(dashGap == 0 && dashWidth > 0)
+          {
+            // Note : this is same logic as bitmap[y][x] = underlineColor;
+            *(bitmapBuffer + x) = packedUnderlineColor;
+            dashWidth--;
+          }
+          else if(dashGap < dashedUnderlineGap)
+          {
+            dashGap++;
+          }
+          else
+          {
+            //reset
+            dashWidth = dashedUnderlineWidth;
+            dashGap   = 0;
+          }
         }
-        WriteColorToPixelBuffer(glyphData, bitmapBuffer, underlineColor, x, y);
       }
-    }
-  }
-  if(underlineType == Text::Underline::DOUBLE)
-  {
-    int secondUnderlineYOffset = underlineYOffset - ONE_AND_A_HALF * maxUnderlineHeight;
-    for(unsigned int y = secondUnderlineYOffset; y < secondUnderlineYOffset + maxUnderlineHeight; y++)
-    {
-      if(y > bufferHeight - 1)
+      else
       {
-        // Do not write out of bounds.
-        break;
+        for(uint32_t x = xRangeMin; x < xRangeMax; x++)
+        {
+          // Note : this is same logic as bitmap[y][x] = underlineColor;
+          *(bitmapBuffer + x) = packedUnderlineColor;
+        }
       }
-      for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++)
+      bitmapBuffer += glyphData.width;
+    }
+    if(underlineType == Text::Underline::DOUBLE)
+    {
+      int32_t        secondUnderlineYOffset = underlineYOffset - ONE_AND_A_HALF * maxUnderlineHeight;
+      const uint32_t secondYRangeMin        = static_cast<uint32_t>(std::max(0, secondUnderlineYOffset));
+      const uint32_t secondYRangeMax        = static_cast<uint32_t>(std::max(0, std::min(static_cast<int32_t>(bufferHeight), secondUnderlineYOffset + static_cast<int32_t>(maxUnderlineHeight))));
+
+      // Rewind bitmapBuffer pointer, and skip secondYRangeMin line.
+      bitmapBuffer = reinterpret_cast<uint32_t*>(glyphData.bitmapBuffer.GetBuffer()) + yRangeMin * glyphData.width;
+
+      for(uint32_t y = secondYRangeMin; y < secondYRangeMax; y++)
       {
-        if(x > bufferWidth - 1)
+        for(uint32_t x = xRangeMin; x < xRangeMax; x++)
         {
-          // Do not write out of bounds.
-          break;
+          // Note : this is same logic as bitmap[y][x] = underlineColor;
+          *(bitmapBuffer + x) = packedUnderlineColor;
         }
-        WriteColorToPixelBuffer(glyphData, bitmapBuffer, underlineColor, x, y);
+        bitmapBuffer += glyphData.width;
       }
     }
   }
@@ -379,39 +415,67 @@ void DrawUnderline(
 
 /// Draws the background color to the buffer
 void DrawBackgroundColor(
-  Vector4            backgroundColor,
-  const unsigned int bufferWidth,
-  const unsigned int bufferHeight,
-  GlyphData&         glyphData,
-  const float        baseline,
-  const LineRun&     line,
-  const float        lineExtentLeft,
-  const float        lineExtentRight)
+  Vector4         backgroundColor,
+  const uint32_t& bufferWidth,
+  const uint32_t& bufferHeight,
+  GlyphData&      glyphData,
+  const float&    baseline,
+  const LineRun&  line,
+  const float&    lineExtentLeft,
+  const float&    lineExtentRight)
 {
+  const int32_t yRangeMin = std::max(0, static_cast<int32_t>(glyphData.verticalOffset + baseline - line.ascender));
+  const int32_t yRangeMax = std::min(static_cast<int32_t>(bufferHeight), static_cast<int32_t>(glyphData.verticalOffset + baseline - line.descender));
+  const int32_t xRangeMin = std::max(0, static_cast<int32_t>(glyphData.horizontalOffset + lineExtentLeft));
+  const int32_t xRangeMax = std::min(static_cast<int32_t>(bufferWidth), static_cast<int32_t>(glyphData.horizontalOffset + lineExtentRight + 1)); // Due to include last point, we add 1 here
+
+  // If current glyph don't need to be rendered, just ignore.
+  if(yRangeMax <= yRangeMin || xRangeMax <= xRangeMin)
+  {
+    return;
+  }
+
+  // We can optimize by memset when backgroundColor.a is near zero
+  uint8_t backgroundColorAlpha = static_cast<uint8_t>(backgroundColor.a * 255.f);
+
   uint32_t* bitmapBuffer = reinterpret_cast<uint32_t*>(glyphData.bitmapBuffer.GetBuffer());
 
-  for(int y = glyphData.verticalOffset + baseline - line.ascender; y < glyphData.verticalOffset + baseline - line.descender; y++)
+  // Skip yRangeMin line.
+  bitmapBuffer += yRangeMin * glyphData.width;
+
+  if(backgroundColorAlpha == 0)
   {
-    if((y < 0) || (y > static_cast<int>(bufferHeight - 1)))
+    for(int32_t y = yRangeMin; y < yRangeMax; y++)
     {
-      // Do not write out of bounds.
-      continue;
+      // We can use memset.
+      memset(bitmapBuffer + xRangeMin, 0, (xRangeMax - xRangeMin) * sizeof(uint32_t));
+      bitmapBuffer += glyphData.width;
     }
+  }
+  else
+  {
+    uint32_t packedBackgroundColor       = 0u;
+    uint8_t* packedBackgroundColorBuffer = reinterpret_cast<uint8_t*>(&packedBackgroundColor);
+
+    // Write the color to the pixel buffer
+    *(packedBackgroundColorBuffer + 3u) = backgroundColorAlpha;
+    *(packedBackgroundColorBuffer + 2u) = static_cast<uint8_t>(backgroundColor.b * backgroundColorAlpha);
+    *(packedBackgroundColorBuffer + 1u) = static_cast<uint8_t>(backgroundColor.g * backgroundColorAlpha);
+    *(packedBackgroundColorBuffer)      = static_cast<uint8_t>(backgroundColor.r * backgroundColorAlpha);
 
-    for(int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++)
+    for(int32_t y = yRangeMin; y < yRangeMax; y++)
     {
-      if((x < 0) || (x > static_cast<int>(bufferWidth - 1)))
+      for(int32_t x = xRangeMin; x < xRangeMax; x++)
       {
-        // Do not write out of bounds.
-        continue;
+        // Note : this is same logic as bitmap[y][x] = backgroundColor;
+        *(bitmapBuffer + x) = packedBackgroundColor;
       }
-
-      WriteColorToPixelBuffer(glyphData, bitmapBuffer, backgroundColor, x, y);
+      bitmapBuffer += glyphData.width;
     }
   }
 }
 
-Devel::PixelBuffer DrawGlyphsBackground(const ViewModel* model, Devel::PixelBuffer& buffer, const unsigned int bufferWidth, const unsigned int bufferHeight, bool ignoreHorizontalAlignment, int horizontalOffset, int verticalOffset)
+Devel::PixelBuffer DrawGlyphsBackground(const ViewModel* model, Devel::PixelBuffer& buffer, const uint32_t& bufferWidth, const uint32_t& bufferHeight, bool ignoreHorizontalAlignment, int32_t horizontalOffset, int32_t verticalOffset)
 {
   // Retrieve lines, glyphs, positions and colors from the view model.
   const Length            modelNumberOfLines           = model->GetNumberOfLines();
@@ -439,16 +503,16 @@ Devel::PixelBuffer DrawGlyphsBackground(const ViewModel* model, Devel::PixelBuff
     const LineRun& line = *(modelLinesBuffer + lineIndex);
 
     // Sets the horizontal offset of the line.
-    glyphData.horizontalOffset = ignoreHorizontalAlignment ? 0 : static_cast<int>(line.alignmentOffset);
+    glyphData.horizontalOffset = ignoreHorizontalAlignment ? 0 : static_cast<int32_t>(line.alignmentOffset);
     glyphData.horizontalOffset += horizontalOffset;
 
     // Increases the vertical offset with the line's ascender.
-    glyphData.verticalOffset += static_cast<int>(line.ascender);
+    glyphData.verticalOffset += static_cast<int32_t>(line.ascender);
 
     // Include line spacing after first line
     if(lineIndex > 0u)
     {
-      glyphData.verticalOffset += static_cast<int>(line.lineSpacing);
+      glyphData.verticalOffset += static_cast<int32_t>(line.lineSpacing);
     }
 
     float left     = bufferWidth;
@@ -515,71 +579,98 @@ Devel::PixelBuffer DrawGlyphsBackground(const ViewModel* model, Devel::PixelBuff
     }
 
     // Increases the vertical offset with the line's descender.
-    glyphData.verticalOffset += static_cast<int>(-line.descender);
+    glyphData.verticalOffset += static_cast<int32_t>(-line.descender);
   }
 
   return glyphData.bitmapBuffer;
 }
 
 /// Draws the specified strikethrough color to the buffer
-void DrawStrikethrough(const unsigned int                  bufferWidth,
-                       const unsigned int                  bufferHeight,
+void DrawStrikethrough(const uint32_t&                     bufferWidth,
+                       const uint32_t&                     bufferHeight,
                        GlyphData&                          glyphData,
-                       const float                         baseline,
-                       const float                         strikethroughStartingYPosition,
-                       const float                         maxStrikethroughHeight,
-                       const float                         lineExtentLeft,
-                       const float                         lineExtentRight,
+                       const float&                        baseline,
+                       const float&                        strikethroughStartingYPosition,
+                       const float&                        maxStrikethroughHeight,
+                       const float&                        lineExtentLeft,
+                       const float&                        lineExtentRight,
                        const StrikethroughStyleProperties& commonStrikethroughProperties,
                        const StrikethroughStyleProperties& currentStrikethroughProperties,
                        const LineRun&                      line)
 {
   const Vector4& strikethroughColor = currentStrikethroughProperties.colorDefined ? currentStrikethroughProperties.color : commonStrikethroughProperties.color;
 
+  const uint32_t yRangeMin = static_cast<uint32_t>(strikethroughStartingYPosition);
+  const uint32_t yRangeMax = std::min(bufferHeight, static_cast<uint32_t>(strikethroughStartingYPosition + maxStrikethroughHeight));
+  const uint32_t xRangeMin = static_cast<uint32_t>(glyphData.horizontalOffset + lineExtentLeft);
+  const uint32_t xRangeMax = std::min(bufferWidth, static_cast<uint32_t>(glyphData.horizontalOffset + lineExtentRight + 1)); // Due to include last point, we add 1 here
+
+  // If current glyph don't need to be rendered, just ignore.
+  if(yRangeMax <= yRangeMin || xRangeMax <= xRangeMin)
+  {
+    return;
+  }
+
+  // We can optimize by memset when strikethroughColor.a is near zero
+  uint8_t strikethroughColorAlpha = static_cast<uint8_t>(strikethroughColor.a * 255.f);
+
   uint32_t* bitmapBuffer = reinterpret_cast<uint32_t*>(glyphData.bitmapBuffer.GetBuffer());
 
-  for(unsigned int y = strikethroughStartingYPosition; y < strikethroughStartingYPosition + maxStrikethroughHeight; y++)
+  // Skip yRangeMin line.
+  bitmapBuffer += yRangeMin * glyphData.width;
+
+  if(strikethroughColorAlpha == 0)
   {
-    if(y > bufferHeight - 1)
+    for(uint32_t y = yRangeMin; y < yRangeMax; y++)
     {
-      // Do not write out of bounds.
-      break;
+      // We can use memset.
+      memset(bitmapBuffer + xRangeMin, 0, (xRangeMax - xRangeMin) * sizeof(uint32_t));
+      bitmapBuffer += glyphData.width;
     }
+  }
+  else
+  {
+    uint32_t packedStrikethroughColor       = 0u;
+    uint8_t* packedStrikethroughColorBuffer = reinterpret_cast<uint8_t*>(&packedStrikethroughColor);
+
+    // Write the color to the pixel buffer
+    *(packedStrikethroughColorBuffer + 3u) = strikethroughColorAlpha;
+    *(packedStrikethroughColorBuffer + 2u) = static_cast<uint8_t>(strikethroughColor.b * strikethroughColorAlpha);
+    *(packedStrikethroughColorBuffer + 1u) = static_cast<uint8_t>(strikethroughColor.g * strikethroughColorAlpha);
+    *(packedStrikethroughColorBuffer)      = static_cast<uint8_t>(strikethroughColor.r * strikethroughColorAlpha);
 
-    for(unsigned int x = glyphData.horizontalOffset + lineExtentLeft; x <= glyphData.horizontalOffset + lineExtentRight; x++)
+    for(uint32_t y = yRangeMin; y < yRangeMax; y++)
     {
-      if(x > bufferWidth - 1)
+      for(uint32_t x = xRangeMin; x < xRangeMax; x++)
       {
-        // Do not write out of bounds.
-        break;
+        // Note : this is same logic as bitmap[y][x] = strikethroughColor;
+        *(bitmapBuffer + x) = packedStrikethroughColor;
       }
-
-      WriteColorToPixelBuffer(glyphData, bitmapBuffer, strikethroughColor, x, y);
+      bitmapBuffer += glyphData.width;
     }
   }
 }
 
-} // namespace
-
-TypesetterPtr Typesetter::New(const ModelInterface* const model)
-{
-  return TypesetterPtr(new Typesetter(model));
-}
-
-ViewModel* Typesetter::GetViewModel()
-{
-  return mModel;
-}
-
-Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, const unsigned int bufferHeight, Pixel::Format pixelFormat)
+/**
+ * @brief Create an initialized image buffer filled with transparent color.
+ *
+ * Creates the pixel data used to generate the final image with the given size.
+ *
+ * @param[in] bufferWidth The width of the image buffer.
+ * @param[in] bufferHeight The height of the image buffer.
+ * @param[in] pixelFormat The format of the pixel in the image that the text is rendered as (i.e. either Pixel::BGRA8888 or Pixel::L8).
+ *
+ * @return An image buffer.
+ */
+inline Devel::PixelBuffer CreateTransparentImageBuffer(const uint32_t& bufferWidth, const uint32_t& bufferHeight, const Pixel::Format& pixelFormat)
 {
   Devel::PixelBuffer imageBuffer = Devel::PixelBuffer::New(bufferWidth, bufferHeight, pixelFormat);
 
   if(Pixel::RGBA8888 == pixelFormat)
   {
-    const unsigned int bufferSizeInt  = bufferWidth * bufferHeight;
-    const unsigned int bufferSizeChar = 4u * bufferSizeInt;
-    memset(imageBuffer.GetBuffer(), 0u, bufferSizeChar);
+    const uint32_t bufferSizeInt  = bufferWidth * bufferHeight;
+    const uint32_t bufferSizeChar = sizeof(uint32_t) * bufferSizeInt;
+    memset(imageBuffer.GetBuffer(), 0, bufferSizeChar);
   }
   else
   {
@@ -589,6 +680,125 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth,
   return imageBuffer;
 }
 
+/**
+ * @brief Combine the two RGBA image buffers together.
+ *
+ * The top layer buffer will blend over the bottom layer buffer:
+ * - If the pixel is not fully opaque from either buffer, it will be blended with
+ *   the pixel from the other buffer and copied to the combined buffer.
+ * - If the pixels from both buffers are fully opaque, the pixels from the top layer
+ *   buffer will be copied to the combined buffer.
+ *
+ * Due to the performance issue, We need to re-use input'ed pixelBuffer memory.
+ * We can determine which pixelBuffer's memory is destination
+ *
+ * @param[in, out] topPixelBuffer The top layer buffer.
+ * @param[in, out] bottomPixelBuffer The bottom layer buffer.
+ * @param[in] bufferWidth The width of the image buffer.
+ * @param[in] bufferHeight The height of the image buffer.
+ * @param[in] storeResultIntoTop True if we store the combined image buffer result into topPixelBuffer.
+ * False if we store the combined image buffer result into bottomPixelBuffer.
+ *
+ */
+void CombineImageBuffer(Devel::PixelBuffer& topPixelBuffer, Devel::PixelBuffer& bottomPixelBuffer, const uint32_t& bufferWidth, const uint32_t& bufferHeight, bool storeResultIntoTop)
+{
+  // Assume that we always combine two RGBA images
+  // Jump with 4bytes for optimize runtime.
+  uint32_t* topBuffer    = reinterpret_cast<uint32_t*>(topPixelBuffer.GetBuffer());
+  uint32_t* bottomBuffer = reinterpret_cast<uint32_t*>(bottomPixelBuffer.GetBuffer());
+
+  if(topBuffer == NULL && bottomBuffer == NULL)
+  {
+    // Nothing to do if both buffers are empty.
+    return;
+  }
+
+  if(topBuffer == NULL)
+  {
+    // Nothing to do if topBuffer is empty.
+    // If we need to store the result into top, change topPixelBuffer as bottomPixelBuffer.
+    if(storeResultIntoTop)
+    {
+      topPixelBuffer = bottomPixelBuffer;
+    }
+    return;
+  }
+
+  if(bottomBuffer == NULL)
+  {
+    // Nothing to do if bottomBuffer is empty.
+    // If we need to store the result into bottom, change bottomPixelBuffer as topPixelBuffer.
+    if(!storeResultIntoTop)
+    {
+      bottomPixelBuffer = topPixelBuffer;
+    }
+    return;
+  }
+
+  const uint32_t bufferSizeInt = bufferWidth * bufferHeight;
+
+  uint32_t* combinedBuffer        = storeResultIntoTop ? topBuffer : bottomBuffer;
+  uint8_t*  topAlphaBufferPointer = reinterpret_cast<uint8_t*>(topBuffer) + 3;
+
+  for(uint32_t pixelIndex = 0; pixelIndex < bufferSizeInt; ++pixelIndex)
+  {
+    // If the alpha of the pixel in either buffer is not fully opaque, blend the two pixels.
+    // Otherwise, copy pixel from topBuffer to combinedBuffer.
+    // Note : Be careful when we read & write into combinedBuffer. It can be write into same pointer.
+
+    uint8_t topAlpha = *topAlphaBufferPointer;
+
+    if(topAlpha == 0)
+    {
+      // Copy the pixel from bottomBuffer to combinedBuffer
+      if(storeResultIntoTop)
+      {
+        *(combinedBuffer) = *(bottomBuffer);
+      }
+    }
+    else if(topAlpha == 255)
+    {
+      // Copy the pixel from topBuffer to combinedBuffer
+      if(!storeResultIntoTop)
+      {
+        *(combinedBuffer) = *(topBuffer);
+      }
+    }
+    else
+    {
+      // At least one pixel is not fully opaque
+      // "Over" blend the the pixel from topBuffer with the pixel in bottomBuffer
+      uint32_t blendedBottomBufferColor       = *(bottomBuffer);
+      uint8_t* blendedBottomBufferColorBuffer = reinterpret_cast<uint8_t*>(&blendedBottomBufferColor);
+
+      blendedBottomBufferColorBuffer[0] = MultiplyAndNormalizeColor(blendedBottomBufferColorBuffer[0], 255 - topAlpha);
+      blendedBottomBufferColorBuffer[1] = MultiplyAndNormalizeColor(blendedBottomBufferColorBuffer[1], 255 - topAlpha);
+      blendedBottomBufferColorBuffer[2] = MultiplyAndNormalizeColor(blendedBottomBufferColorBuffer[2], 255 - topAlpha);
+      blendedBottomBufferColorBuffer[3] = MultiplyAndNormalizeColor(blendedBottomBufferColorBuffer[3], 255 - topAlpha);
+
+      *(combinedBuffer) = *(topBuffer) + blendedBottomBufferColor;
+    }
+
+    // Increase each buffer's pointer.
+    ++combinedBuffer;
+    ++topBuffer;
+    ++bottomBuffer;
+    topAlphaBufferPointer += sizeof(uint32_t) / sizeof(uint8_t);
+  }
+}
+
+} // namespace
+
+TypesetterPtr Typesetter::New(const ModelInterface* const model)
+{
+  return TypesetterPtr(new Typesetter(model));
+}
+
+ViewModel* Typesetter::GetViewModel()
+{
+  return mModel;
+}
+
 PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirection::Type textDirection, RenderBehaviour behaviour, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat)
 {
   // @todo. This initial implementation for a TextLabel has only one visible page.
@@ -599,10 +809,10 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
   // Retrieves the layout size.
   const Size& layoutSize = mModel->GetLayoutSize();
 
-  const int outlineWidth = static_cast<int>(mModel->GetOutlineWidth());
+  const int32_t outlineWidth = static_cast<int32_t>(mModel->GetOutlineWidth());
 
   // Set the offset for the horizontal alignment according to the text direction and outline width.
-  int penX = 0;
+  int32_t penX = 0;
 
   switch(mModel->GetHorizontalAlignment())
   {
@@ -624,7 +834,7 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
   }
 
   // Set the offset for the vertical alignment.
-  int penY = 0u;
+  int32_t penY = 0u;
 
   switch(mModel->GetVerticalAlignment())
   {
@@ -635,13 +845,13 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
     }
     case VerticalAlignment::CENTER:
     {
-      penY = static_cast<int>(0.5f * (size.height - layoutSize.height));
+      penY = static_cast<int32_t>(0.5f * (size.height - layoutSize.height));
       penY = penY < 0.f ? 0.f : penY;
       break;
     }
     case VerticalAlignment::BOTTOM:
     {
-      penY = static_cast<int>(size.height - layoutSize.height);
+      penY = static_cast<int32_t>(size.height - layoutSize.height);
       break;
     }
   }
@@ -657,14 +867,14 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
     {
       const auto& line = *mModel->GetLines();
       penY -= line.descender;
-      penY += static_cast<int>(line.lineSpacing * 0.5f + line.descender);
+      penY += static_cast<int32_t>(line.lineSpacing * 0.5f + line.descender);
       break;
     }
     case DevelText::VerticalLineAlignment::BOTTOM:
     {
       const auto& line       = *mModel->GetLines();
       const auto  lineHeight = line.ascender + (-line.descender) + line.lineSpacing;
-      penY += static_cast<int>(lineHeight - (line.ascender - line.descender));
+      penY += static_cast<int32_t>(lineHeight - (line.ascender - line.descender));
       break;
     }
   }
@@ -674,11 +884,11 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
   // do all of these in CPU only, so that once the final texture is generated,
   // no calculation is needed in GPU during each frame.
 
-  const unsigned int bufferWidth  = static_cast<unsigned int>(size.width);
-  const unsigned int bufferHeight = static_cast<unsigned int>(size.height);
+  const uint32_t bufferWidth  = static_cast<uint32_t>(size.width);
+  const uint32_t bufferHeight = static_cast<uint32_t>(size.height);
 
-  const unsigned int bufferSizeInt  = bufferWidth * bufferHeight;
-  const unsigned int bufferSizeChar = 4u * bufferSizeInt;
+  const uint32_t bufferSizeInt  = bufferWidth * bufferHeight;
+  const uint32_t bufferSizeChar = sizeof(uint32_t) * bufferSizeInt;
 
   //Elided text in ellipsis at START could start on index greater than 0
   auto startIndexOfGlyphs = mModel->GetStartIndexOfElidedGlyphs();
@@ -713,7 +923,7 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
       Devel::PixelBuffer outlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_OUTLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, startIndexOfGlyphs, endIndexOfGlyphs);
 
       // Combine the two buffers
-      imageBuffer = CombineImageBuffer(imageBuffer, outlineImageBuffer, bufferWidth, bufferHeight);
+      CombineImageBuffer(imageBuffer, outlineImageBuffer, bufferWidth, bufferHeight, true);
     }
 
     // @todo. Support shadow and underline for partial text later on.
@@ -734,7 +944,7 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
       }
 
       // Combine the two buffers
-      imageBuffer = CombineImageBuffer(imageBuffer, shadowImageBuffer, bufferWidth, bufferHeight);
+      CombineImageBuffer(imageBuffer, shadowImageBuffer, bufferWidth, bufferHeight, true);
     }
 
     // Generate the underline if enabled
@@ -745,7 +955,7 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
       Devel::PixelBuffer underlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_UNDERLINE, ignoreHorizontalAlignment, pixelFormat, penX, penY, startIndexOfGlyphs, endIndexOfGlyphs);
 
       // Combine the two buffers
-      imageBuffer = CombineImageBuffer(imageBuffer, underlineImageBuffer, bufferWidth, bufferHeight);
+      CombineImageBuffer(imageBuffer, underlineImageBuffer, bufferWidth, bufferHeight, true);
     }
 
     // Generate the background if enabled
@@ -761,7 +971,7 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
       }
       else
       {
-        backgroundImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, pixelFormat);
+        backgroundImageBuffer = CreateTransparentImageBuffer(bufferWidth, bufferHeight, pixelFormat);
       }
 
       if(backgroundMarkupSet)
@@ -770,7 +980,7 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
       }
 
       // Combine the two buffers
-      imageBuffer = CombineImageBuffer(imageBuffer, backgroundImageBuffer, bufferWidth, bufferHeight);
+      CombineImageBuffer(imageBuffer, backgroundImageBuffer, bufferWidth, bufferHeight, true);
     }
 
     // Generate the strikethrough if enabled
@@ -781,7 +991,7 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
       Devel::PixelBuffer strikethroughImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_STRIKETHROUGH, ignoreHorizontalAlignment, pixelFormat, penX, penY, 0u, endIndexOfGlyphs);
 
       // Combine the two buffers
-      imageBuffer = CombineImageBuffer(imageBuffer, strikethroughImageBuffer, bufferWidth, bufferHeight);
+      CombineImageBuffer(imageBuffer, strikethroughImageBuffer, bufferWidth, bufferHeight, true);
     }
 
     // Markup-Processor
@@ -795,7 +1005,7 @@ PixelData Typesetter::Render(const Vector2& size, Toolkit::DevelText::TextDirect
   return pixelData;
 }
 
-Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth, const unsigned int bufferHeight, Typesetter::Style style, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset, GlyphIndex fromGlyphIndex, GlyphIndex toGlyphIndex)
+Devel::PixelBuffer Typesetter::CreateImageBuffer(const uint32_t& bufferWidth, const uint32_t& bufferHeight, Typesetter::Style style, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, const int32_t& horizontalOffset, const int32_t& verticalOffset, GlyphIndex fromGlyphIndex, GlyphIndex toGlyphIndex)
 {
   // Retrieve lines, glyphs, positions and colors from the view model.
   const Length            modelNumberOfLines = mModel->GetNumberOfLines();
@@ -824,7 +1034,7 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth,
   glyphData.verticalOffset   = verticalOffset;
   glyphData.width            = bufferWidth;
   glyphData.height           = bufferHeight;
-  glyphData.bitmapBuffer     = CreateImageBuffer(bufferWidth, bufferHeight, pixelFormat);
+  glyphData.bitmapBuffer     = CreateTransparentImageBuffer(bufferWidth, bufferHeight, pixelFormat);
   glyphData.horizontalOffset = 0;
 
   // Get a handle of the font client. Used to retrieve the bitmaps of the glyphs.
@@ -842,11 +1052,11 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth,
     const LineRun& line = *(modelLinesBuffer + lineIndex);
 
     // Sets the horizontal offset of the line.
-    glyphData.horizontalOffset = ignoreHorizontalAlignment ? 0 : static_cast<int>(line.alignmentOffset);
+    glyphData.horizontalOffset = ignoreHorizontalAlignment ? 0 : static_cast<int32_t>(line.alignmentOffset);
     glyphData.horizontalOffset += horizontalOffset;
 
     // Increases the vertical offset with the line's ascender.
-    glyphData.verticalOffset += static_cast<int>(line.ascender);
+    glyphData.verticalOffset += static_cast<int32_t>(line.ascender);
 
     // Retrieves the glyph's outline width
     float outlineWidth = static_cast<float>(mModel->GetOutlineWidth());
@@ -930,18 +1140,12 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth,
     bool  addHyphen       = false;
 
     // Traverses the glyphs of the line.
-    const GlyphIndex startGlyphIndex = std::max(line.glyphRun.glyphIndex, startIndexOfGlyphs);
+    const GlyphIndex startGlyphIndex = std::max(std::max(line.glyphRun.glyphIndex, startIndexOfGlyphs), fromGlyphIndex);
     GlyphIndex       endGlyphIndex   = (line.isSplitToTwoHalves ? line.glyphRunSecondHalf.glyphIndex + line.glyphRunSecondHalf.numberOfGlyphs : line.glyphRun.glyphIndex + line.glyphRun.numberOfGlyphs) - 1u;
-    endGlyphIndex                    = std::min(endGlyphIndex, endIndexOfGlyphs);
+    endGlyphIndex                    = std::min(std::min(endGlyphIndex, endIndexOfGlyphs), toGlyphIndex);
 
     for(GlyphIndex glyphIndex = startGlyphIndex; glyphIndex <= endGlyphIndex; ++glyphIndex)
     {
-      if(glyphIndex < fromGlyphIndex || glyphIndex > toGlyphIndex)
-      {
-        // Ignore any glyph that out of the specified range
-        continue;
-      }
-
       //To handle START case of ellipsis, the first glyph has been shifted
       //glyphIndex represent indices in whole glyphs but elidedGlyphIndex represents indices in elided Glyphs
       GlyphIndex elidedGlyphIndex = glyphIndex - startIndexOfGlyphs;
@@ -1085,7 +1289,7 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth,
                                 glyphInfo->isItalicRequired,
                                 glyphInfo->isBoldRequired,
                                 glyphData.glyphBitmap,
-                                static_cast<int>(outlineWidth));
+                                static_cast<int32_t>(outlineWidth));
       }
 
       // Sets the glyph's bitmap into the bitmap of the whole text.
@@ -1153,75 +1357,13 @@ Devel::PixelBuffer Typesetter::CreateImageBuffer(const unsigned int bufferWidth,
     }
 
     // Increases the vertical offset with the line's descender & line spacing.
-    glyphData.verticalOffset += static_cast<int>(-line.descender+line.lineSpacing);
+    glyphData.verticalOffset += static_cast<int32_t>(-line.descender + line.lineSpacing);
   }
 
   return glyphData.bitmapBuffer;
 }
 
-Devel::PixelBuffer Typesetter::CombineImageBuffer(Devel::PixelBuffer topPixelBuffer, Devel::PixelBuffer bottomPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight)
-{
-  unsigned char* topBuffer    = topPixelBuffer.GetBuffer();
-  unsigned char* bottomBuffer = bottomPixelBuffer.GetBuffer();
-
-  Devel::PixelBuffer combinedPixelBuffer;
-
-  if(topBuffer == NULL && bottomBuffer == NULL)
-  {
-    // Nothing to do if both buffers are empty.
-    return combinedPixelBuffer;
-  }
-
-  if(topBuffer == NULL)
-  {
-    // Nothing to do if topBuffer is empty.
-    return bottomPixelBuffer;
-  }
-
-  if(bottomBuffer == NULL)
-  {
-    // Nothing to do if bottomBuffer is empty.
-    return topPixelBuffer;
-  }
-
-  // Always combine two RGBA images
-  const unsigned int bufferSizeInt  = bufferWidth * bufferHeight;
-  const unsigned int bufferSizeChar = 4u * bufferSizeInt;
-
-  combinedPixelBuffer     = Devel::PixelBuffer::New(bufferWidth, bufferHeight, Pixel::RGBA8888);
-  uint8_t* combinedBuffer = reinterpret_cast<uint8_t*>(combinedPixelBuffer.GetBuffer());
-  memset(combinedBuffer, 0u, bufferSizeChar);
-
-  for(unsigned int pixelIndex = 0; pixelIndex < bufferSizeInt; pixelIndex++)
-  {
-    // If the alpha of the pixel in either buffer is not fully opaque, blend the two pixels.
-    // Otherwise, copy pixel from topBuffer to combinedBuffer.
-
-    unsigned int alphaBuffer1 = topBuffer[pixelIndex * 4 + 3];
-
-    if(alphaBuffer1 != 255)
-    {
-      // At least one pixel is not fully opaque
-      // "Over" blend the the pixel from topBuffer with the pixel in bottomBuffer
-      combinedBuffer[pixelIndex * 4]     = topBuffer[pixelIndex * 4] + (bottomBuffer[pixelIndex * 4] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
-      combinedBuffer[pixelIndex * 4 + 1] = topBuffer[pixelIndex * 4 + 1] + (bottomBuffer[pixelIndex * 4 + 1] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
-      combinedBuffer[pixelIndex * 4 + 2] = topBuffer[pixelIndex * 4 + 2] + (bottomBuffer[pixelIndex * 4 + 2] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
-      combinedBuffer[pixelIndex * 4 + 3] = topBuffer[pixelIndex * 4 + 3] + (bottomBuffer[pixelIndex * 4 + 3] * (255 - topBuffer[pixelIndex * 4 + 3]) / 255);
-    }
-    else
-    {
-      // Copy the pixel from topBuffer to combinedBuffer
-      combinedBuffer[pixelIndex * 4]     = topBuffer[pixelIndex * 4];
-      combinedBuffer[pixelIndex * 4 + 1] = topBuffer[pixelIndex * 4 + 1];
-      combinedBuffer[pixelIndex * 4 + 2] = topBuffer[pixelIndex * 4 + 2];
-      combinedBuffer[pixelIndex * 4 + 3] = topBuffer[pixelIndex * 4 + 3];
-    }
-  }
-
-  return combinedPixelBuffer;
-}
-
-Devel::PixelBuffer Typesetter::ApplyUnderlineMarkupImageBuffer(Devel::PixelBuffer topPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset)
+Devel::PixelBuffer Typesetter::ApplyUnderlineMarkupImageBuffer(Devel::PixelBuffer topPixelBuffer, const uint32_t& bufferWidth, const uint32_t& bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, const int32_t& horizontalOffset, const int32_t& verticalOffset)
 {
   // Underline-tags (this is for Markup case)
   // Get the underline runs.
@@ -1244,7 +1386,8 @@ Devel::PixelBuffer Typesetter::ApplyUnderlineMarkupImageBuffer(Devel::PixelBuffe
     // Create the image buffer for underline
     Devel::PixelBuffer underlineImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_UNDERLINE, ignoreHorizontalAlignment, pixelFormat, horizontalOffset, verticalOffset, startGlyphIndex, endGlyphIndex);
     // Combine the two buffers
-    topPixelBuffer = CombineImageBuffer(underlineImageBuffer, topPixelBuffer, bufferWidth, bufferHeight);
+    // Result pixel buffer will be stored into topPixelBuffer.
+    CombineImageBuffer(underlineImageBuffer, topPixelBuffer, bufferWidth, bufferHeight, false);
 
     itGlyphRun++;
   }
@@ -1252,7 +1395,7 @@ Devel::PixelBuffer Typesetter::ApplyUnderlineMarkupImageBuffer(Devel::PixelBuffe
   return topPixelBuffer;
 }
 
-Devel::PixelBuffer Typesetter::ApplyStrikethroughMarkupImageBuffer(Devel::PixelBuffer topPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset)
+Devel::PixelBuffer Typesetter::ApplyStrikethroughMarkupImageBuffer(Devel::PixelBuffer topPixelBuffer, const uint32_t& bufferWidth, const uint32_t& bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, const int32_t& horizontalOffset, const int32_t& verticalOffset)
 {
   // strikethrough-tags (this is for Markup case)
   // Get the strikethrough runs.
@@ -1275,7 +1418,8 @@ Devel::PixelBuffer Typesetter::ApplyStrikethroughMarkupImageBuffer(Devel::PixelB
     // Create the image buffer for strikethrough
     Devel::PixelBuffer strikethroughImageBuffer = CreateImageBuffer(bufferWidth, bufferHeight, Typesetter::STYLE_STRIKETHROUGH, ignoreHorizontalAlignment, pixelFormat, horizontalOffset, verticalOffset, startGlyphIndex, endGlyphIndex);
     // Combine the two buffers
-    topPixelBuffer = CombineImageBuffer(strikethroughImageBuffer, topPixelBuffer, bufferWidth, bufferHeight);
+    // Result pixel buffer will be stored into topPixelBuffer.
+    CombineImageBuffer(strikethroughImageBuffer, topPixelBuffer, bufferWidth, bufferHeight, false);
 
     itGlyphRun++;
   }
@@ -1283,7 +1427,7 @@ Devel::PixelBuffer Typesetter::ApplyStrikethroughMarkupImageBuffer(Devel::PixelB
   return topPixelBuffer;
 }
 
-Devel::PixelBuffer Typesetter::ApplyMarkupProcessorOnPixelBuffer(Devel::PixelBuffer topPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset)
+Devel::PixelBuffer Typesetter::ApplyMarkupProcessorOnPixelBuffer(Devel::PixelBuffer topPixelBuffer, const uint32_t& bufferWidth, const uint32_t& bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, const int32_t& horizontalOffset, const int32_t& verticalOffset)
 {
   // Apply the markup-Processor if enabled
   const bool markupProcessorEnabled = mModel->IsMarkupProcessorEnabled();
index bf46b90..3f9dd66 100644 (file)
@@ -144,39 +144,7 @@ private:
    *
    * @return An image buffer with the text.
    */
-  Devel::PixelBuffer CreateImageBuffer(const unsigned int bufferWidth, const unsigned int bufferHeight, Typesetter::Style style, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset, TextAbstraction::GlyphIndex fromGlyphIndex, TextAbstraction::GlyphIndex toGlyphIndex);
-
-  /**
-   * @brief Create an initialized image buffer.
-   *
-   * Creates the pixel data used to generate the final image with the given size.
-   *
-   * @param[in] bufferWidth The width of the image buffer.
-   * @param[in] bufferHeight The height of the image buffer.
-   * @param[in] pixelFormat The format of the pixel in the image that the text is rendered as (i.e. either Pixel::BGRA8888 or Pixel::L8).
-   *
-   * @return An image buffer.
-   */
-  Devel::PixelBuffer CreateImageBuffer(const unsigned int bufferWidth, const unsigned int bufferHeight, Pixel::Format pixelFormat);
-
-  /**
-   * @brief Combine the two RGBA image buffers together.
-   *
-   * The top layer buffer will blend over the bottom layer buffer:
-   * - If the pixel is not fully opaque from either buffer, it will be blended with
-   *   the pixel from the other buffer and copied to the combined buffer.
-   * - If the pixels from both buffers are fully opaque, the pixels from the top layer
-   *   buffer will be copied to the combined buffer.
-   *
-   * @param[in] topPixelBuffer The top layer buffer.
-   * @param[in] bottomPixelBuffer The bottom layer buffer.
-   * @param[in] bufferWidth The width of the image buffer.
-   * @param[in] bufferHeight The height of the image buffer.
-   *
-   * @return The combined image buffer with the text.
-   *
-   */
-  Devel::PixelBuffer CombineImageBuffer(Devel::PixelBuffer topPixelBuffer, Devel::PixelBuffer bottomPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeightbool);
+  Devel::PixelBuffer CreateImageBuffer(const uint32_t& bufferWidth, const uint32_t& bufferHeight, Typesetter::Style style, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, const int32_t& horizontalOffset, const int32_t& verticalOffset, TextAbstraction::GlyphIndex fromGlyphIndex, TextAbstraction::GlyphIndex toGlyphIndex);
 
   /**
    * @brief Apply behaviour of tags if the markup-processor is enabled.
@@ -191,7 +159,7 @@ private:
    *
    * @return The image buffer with the markup.
    */
-  Devel::PixelBuffer ApplyMarkupProcessorOnPixelBuffer(Devel::PixelBuffer topPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset);
+  Devel::PixelBuffer ApplyMarkupProcessorOnPixelBuffer(Devel::PixelBuffer topPixelBuffer, const uint32_t& bufferWidth, const uint32_t& bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, const int32_t& horizontalOffset, const int32_t& verticalOffset);
 
   /**
    * @brief Apply markup underline tags.
@@ -212,7 +180,7 @@ private:
    *
    * @return The image buffer with the markup.
    */
-  Devel::PixelBuffer ApplyUnderlineMarkupImageBuffer(Devel::PixelBuffer topPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset);
+  Devel::PixelBuffer ApplyUnderlineMarkupImageBuffer(Devel::PixelBuffer topPixelBuffer, const uint32_t& bufferWidth, const uint32_t& bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, const int32_t& horizontalOffset, const int32_t& verticalOffset);
 
   /**
    * @brief Apply markup strikethrough tags.
@@ -233,7 +201,7 @@ private:
    *
    * @return The image buffer with the markup.
    */
-  Devel::PixelBuffer ApplyStrikethroughMarkupImageBuffer(Devel::PixelBuffer topPixelBuffer, const unsigned int bufferWidth, const unsigned int bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, int horizontalOffset, int verticalOffset);
+  Devel::PixelBuffer ApplyStrikethroughMarkupImageBuffer(Devel::PixelBuffer topPixelBuffer, const uint32_t& bufferWidth, const uint32_t& bufferHeight, bool ignoreHorizontalAlignment, Pixel::Format pixelFormat, const int32_t& horizontalOffset, const int32_t& verticalOffset);
 
 protected:
   /**
index 08e416e..24f9981 100644 (file)
@@ -33,8 +33,8 @@ namespace Toolkit
 {
 namespace Internal
 {
-RasterizingTask::RasterizingTask(SvgVisual* svgRenderer, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, unsigned int width, unsigned int height)
-: mSvgVisual(svgRenderer),
+RasterizingTask::RasterizingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, unsigned int width, unsigned int height)
+: mSvgVisual(svgVisual),
   mVectorRenderer(vectorRenderer),
   mUrl(url),
   mDpi(dpi),
@@ -50,29 +50,41 @@ RasterizingTask::~RasterizingTask()
 
 void RasterizingTask::Load()
 {
+  if(mVectorRenderer.IsLoaded())
+  {
+    // Already loaded
+    mLoadSuccess = true;
+    return;
+  }
+
+  Dali::Vector<uint8_t> buffer;
+
   if(!mUrl.IsLocalResource())
   {
-    Dali::Vector<uint8_t> remoteBuffer;
-    if(!Dali::FileLoader::DownloadFileSynchronously(mUrl.GetUrl(), remoteBuffer))
+    if(!Dali::FileLoader::DownloadFileSynchronously(mUrl.GetUrl(), buffer))
     {
-      DALI_LOG_ERROR("RasterizingTask::Load: Failed to download file! [%s]\n", mUrl.GetUrl().c_str());
+      DALI_LOG_ERROR("Failed to download file! [%s]\n", mUrl.GetUrl().c_str());
       return;
     }
-
-    remoteBuffer.PushBack('\0');
-
-    if(!mVectorRenderer.Load(remoteBuffer, mDpi))
+  }
+  else
+  {
+    if(!Dali::FileLoader::ReadFile(mUrl.GetUrl(), buffer))
     {
-      DALI_LOG_ERROR("RasterizingTask::Load:Failed to load data! [%s]\n", mUrl.GetUrl().c_str());
+      DALI_LOG_ERROR("Failed to read file! [%s]\n", mUrl.GetUrl().c_str());
       return;
     }
-
-    mLoadSuccess = true;
   }
-  else
+
+  buffer.PushBack('\0');
+
+  if(!mVectorRenderer.Load(buffer, mDpi))
   {
-    mLoadSuccess = true;
+    DALI_LOG_ERROR("Failed to load data! [%s]\n", mUrl.GetUrl().c_str());
+    return;
   }
+
+  mLoadSuccess = true;
 }
 
 void RasterizingTask::Rasterize()
@@ -87,11 +99,6 @@ void RasterizingTask::Rasterize()
   mPixelData = Devel::PixelBuffer::Convert(pixelBuffer);
 }
 
-VectorImageRenderer RasterizingTask::GetVectorRenderer() const
-{
-  return mVectorRenderer;
-}
-
 bool RasterizingTask::IsLoaded() const
 {
   return mLoadSuccess;
@@ -258,7 +265,7 @@ void SvgRasterizeThread::ApplyRasterizedSVGToSampler()
 {
   while(RasterizingTaskPtr task = NextCompletedTask())
   {
-    task->GetSvgVisual()->ApplyRasterizedImage(task->GetVectorRenderer(), task->GetPixelData(), task->IsLoaded());
+    task->GetSvgVisual()->ApplyRasterizedImage(task->GetPixelData(), task->IsLoaded());
   }
 
   UnregisterProcessor();
index 0204bef..c0cf726 100644 (file)
@@ -2,7 +2,7 @@
 #define DALI_TOOLKIT_SVG_RASTERIZE_THREAD_H
 
 /*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * 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.
@@ -29,7 +29,6 @@
 #include <dali/public-api/common/vector-wrapper.h>
 #include <dali/public-api/images/pixel-data.h>
 #include <dali/public-api/object/ref-object.h>
-#include <dali/public-api/rendering/texture-set.h>
 #include <memory>
 
 // INTERNAL INCLUDES
@@ -60,12 +59,14 @@ class RasterizingTask : public RefObject
 public:
   /**
    * Constructor
-   * @param[in] svgRenderer The renderer which the rasterized image to be applied.
+   * @param[in] svgVisual The visual which the rasterized image to be applied.
+   * @param[in] vectorRenderer The vector rasterizer.
    * @param[in] url The URL to svg resource to use.
+   * @param[in] dpi The DPI of the screen.
    * @param[in] width The rasterization width.
    * @param[in] height The rasterization height.
    */
-  RasterizingTask(SvgVisual* svgRenderer, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, unsigned int width, unsigned int height);
+  RasterizingTask(SvgVisual* svgVisual, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, unsigned int width, unsigned int height);
 
   /**
    * Destructor.
@@ -73,6 +74,11 @@ public:
   ~RasterizingTask() override;
 
   /**
+   * Load svg file
+   */
+  void Load();
+
+  /**
    * Do the rasterization with the mRasterizer.
    */
   void Rasterize();
@@ -89,21 +95,11 @@ public:
   PixelData GetPixelData() const;
 
   /**
-   * Get the VectorRenderer.
-   * @return VectorRenderer.
-   */
-  VectorImageRenderer GetVectorRenderer() const;
-  /**
    * Whether the resource is loaded.
    * @return True if the resource is loaded.
    */
   bool IsLoaded() const;
 
-  /**
-   * Load svg file
-   */
-  void Load();
-
 private:
   // Undefined
   RasterizingTask(const RasterizingTask& task);
@@ -117,8 +113,8 @@ private:
   VisualUrl           mUrl;
   PixelData           mPixelData;
   float               mDpi;
-  unsigned int        mWidth;
-  unsigned int        mHeight;
+  uint32_t            mWidth;
+  uint32_t            mHeight;
   bool                mLoadSuccess;
 };
 
index 6851c75..bddb7f0 100644 (file)
@@ -27,7 +27,6 @@
 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 
 // EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/file-loader.h>
 #include <dali/devel-api/common/stage.h>
 #include <dali/integration-api/debug.h>
 
@@ -49,7 +48,6 @@ const Dali::Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
 SvgVisualPtr SvgVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties)
 {
   SvgVisualPtr svgVisual(new SvgVisual(factoryCache, shaderFactory, imageUrl));
-  svgVisual->Load();
   svgVisual->SetProperties(properties);
   svgVisual->Initialize();
   return svgVisual;
@@ -58,7 +56,6 @@ SvgVisualPtr SvgVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderF
 SvgVisualPtr SvgVisual::New(VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl)
 {
   SvgVisualPtr svgVisual(new SvgVisual(factoryCache, shaderFactory, imageUrl));
-  svgVisual->Load();
   svgVisual->Initialize();
   return svgVisual;
 }
@@ -238,34 +235,6 @@ void SvgVisual::EnablePreMultipliedAlpha(bool preMultiplied)
   }
 }
 
-void SvgVisual::Load()
-{
-  // load remote resource on svg rasterize thread.
-  if(mImageUrl.IsLocalResource())
-  {
-    Dali::Vector<uint8_t> buffer;
-    if(Dali::FileLoader::ReadFile(mImageUrl.GetUrl(), buffer))
-    {
-      buffer.PushBack('\0');
-
-      Vector2 dpi     = Stage::GetCurrent().GetDpi();
-      float   meanDpi = (dpi.height + dpi.width) * 0.5f;
-      if(!mVectorRenderer.Load(buffer, meanDpi))
-      {
-        mLoadFailed = true;
-        DALI_LOG_ERROR("SvgVisual::Load: Failed to load file! [%s]\n", mImageUrl.GetUrl().c_str());
-        return;
-      }
-      mVectorRenderer.GetDefaultSize(mDefaultWidth, mDefaultHeight);
-    }
-    else
-    {
-      mLoadFailed = true;
-      DALI_LOG_ERROR("SvgVisual::Load: Failed to read file! [%s]\n", mImageUrl.GetUrl().c_str());
-    }
-  }
-}
-
 void SvgVisual::AddRasterizationTask(const Vector2& size)
 {
   if(mImpl->mRenderer)
@@ -277,11 +246,12 @@ void SvgVisual::AddRasterizationTask(const Vector2& size)
     float   meanDpi = (dpi.height + dpi.width) * 0.5f;
 
     RasterizingTaskPtr newTask = new RasterizingTask(this, mVectorRenderer, mImageUrl, meanDpi, width, height);
+
     if(IsSynchronousLoadingRequired() && mImageUrl.IsLocalResource())
     {
       newTask->Load();
       newTask->Rasterize();
-      ApplyRasterizedImage(newTask->GetVectorRenderer(), newTask->GetPixelData(), newTask->IsLoaded());
+      ApplyRasterizedImage(newTask->GetPixelData(), newTask->IsLoaded());
     }
     else
     {
@@ -290,7 +260,7 @@ void SvgVisual::AddRasterizationTask(const Vector2& size)
   }
 }
 
-void SvgVisual::ApplyRasterizedImage(VectorImageRenderer vectorRenderer, PixelData rasterizedPixelData, bool isLoaded)
+void SvgVisual::ApplyRasterizedImage(PixelData rasterizedPixelData, bool isLoaded)
 {
   if(isLoaded && rasterizedPixelData && IsOnScene())
   {
@@ -388,8 +358,8 @@ void SvgVisual::OnSetTransform()
   {
     if(visualSize != mRasterizedSize || mDefaultWidth == 0 || mDefaultHeight == 0)
     {
-      AddRasterizationTask(visualSize);
       mRasterizedSize = visualSize;
+      AddRasterizationTask(visualSize);
     }
   }
 
index 2b1dbe1..9dd6807 100644 (file)
@@ -151,19 +151,13 @@ public:
   /**
    * @bried Apply the rasterized image to the visual.
    *
-   * @param[in] vectorImage The data of vector image.
    * @param[in] rasterizedPixelData The pixel buffer with the rasterized pixels
    * @param[in] bool Whether the resource is loaded
    */
-  void ApplyRasterizedImage(VectorImageRenderer vectorImage, PixelData rasterizedPixelData, bool isLoaded);
+  void ApplyRasterizedImage(PixelData rasterizedPixelData, bool isLoaded);
 
 private:
   /**
-   * @brief Load the SVG Image from the set URL.
-   */
-  void Load();
-
-  /**
    * @bried Rasterize the svg with the given size, and add it to the visual.
    *
    * @param[in] size The target size of the SVG rasterization.
index 9b0e811..9744ca5 100644 (file)
@@ -620,16 +620,16 @@ void TextVisual::CreateTextureSet(TilingInfo& info, VisualRenderer& renderer, Sa
     ++textureSetIndex;
   }
 
-  if(styleEnabled && info.styleBuffer)
+  if(styleEnabled && info.styleBuffer && info.overlayStyleBuffer)
   {
     PixelData styleData = ConvertToPixelData(info.styleBuffer, info.width, info.height, info.offsetPosition, Pixel::RGBA8888);
     AddTexture(textureSet, styleData, sampler, textureSetIndex);
     ++textureSetIndex;
-  }
 
-  if(styleEnabled && isOverlayStyle && info.styleBuffer)
-  {
-    PixelData overlayStyleData = ConvertToPixelData(info.styleBuffer, info.width, info.height, info.offsetPosition, Pixel::RGBA8888);
+    // TODO : We need to seperate whether use overlayStyle or not.
+    // Current text visual shader required both of them.
+
+    PixelData overlayStyleData = ConvertToPixelData(info.overlayStyleBuffer, info.width, info.height, info.offsetPosition, Pixel::RGBA8888);
     AddTexture(textureSet, overlayStyleData, sampler, textureSetIndex);
     ++textureSetIndex;
   }
@@ -711,6 +711,14 @@ void TextVisual::AddRenderer(Actor& actor, const Vector2& size, bool hasMultiple
       PixelData                             styleData      = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_NO_TEXT, false, Pixel::RGBA8888);
       Dali::DevelPixelData::PixelDataBuffer stylePixelData = Dali::DevelPixelData::ReleasePixelDataBuffer(styleData);
       info.styleBuffer                                     = stylePixelData.buffer;
+
+      // TODO : We need to seperate whether use overlayStyle or not.
+      // Current text visual shader required both of them.
+
+      // Create RGBA texture for all the overlay styles
+      PixelData                             overlayStyleData      = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_OVERLAY_STYLE, false, Pixel::RGBA8888);
+      Dali::DevelPixelData::PixelDataBuffer overlayStylePixelData = Dali::DevelPixelData::ReleasePixelDataBuffer(overlayStyleData);
+      info.overlayStyleBuffer                                     = overlayStylePixelData.buffer;
     }
 
     if(containsColorGlyph && !hasMultipleTextColors)
@@ -797,6 +805,10 @@ TextureSet TextVisual::GetTextTexture(const Vector2& size, bool hasMultipleTextC
     PixelData styleData = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_NO_TEXT, false, Pixel::RGBA8888);
     AddTexture(textureSet, styleData, sampler, textureSetIndex);
     ++textureSetIndex;
+
+    // TODO : We need to seperate whether use overlayStyle or not.
+    // Current text visual shader required both of them.
+
     // Create RGBA texture for overlay styles such as underline and strikethrough (without the text itself)
     PixelData overlayStyleData = mTypesetter->Render(size, textDirection, Text::Typesetter::RENDER_OVERLAY_STYLE, false, Pixel::RGBA8888);
     AddTexture(textureSet, overlayStyleData, sampler, textureSetIndex);
index fa7ca4e..c79c254 100644 (file)
@@ -193,6 +193,7 @@ private:
   {
     unsigned char* textBuffer;
     unsigned char* styleBuffer;
+    unsigned char* overlayStyleBuffer;
     unsigned char* maskBuffer;
     int            width;
     int            height;
@@ -203,6 +204,7 @@ private:
     TilingInfo(int width, int height, Pixel::Format textPixelFormat)
     : textBuffer(NULL),
       styleBuffer(NULL),
+      overlayStyleBuffer(NULL),
       maskBuffer(NULL),
       width(width),
       height(height),
@@ -222,6 +224,10 @@ private:
       {
         free(styleBuffer);
       }
+      if(overlayStyleBuffer)
+      {
+        free(overlayStyleBuffer);
+      }
       if(maskBuffer)
       {
         free(maskBuffer);