automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-vector-image-renderer.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <dali/devel-api/adaptor-framework/vector-image-renderer.h>
  19 #include <dali/public-api/object/base-object.h>
  20 #include <dali/public-api/rendering/renderer.h>
  21 #include <sys/stat.h>
  22 #include <toolkit-application.h>
  23 #include <toolkit-event-thread-callback.h>
  24 #include <cstring>
  25 #include <memory>
  26
  27 namespace Dali
  28 {
  29 namespace Internal
  30 {
  31 namespace Adaptor
  32 {
  33 class VectorImageRenderer : public Dali::BaseObject
  34 {
  35 public:
  36   VectorImageRenderer()
  37   : mWidth(0),
  38     mHeight(0),
  39     mRasterizeSuccess(true)
  40   {
  41   }
  42
  43   ~VectorImageRenderer()
  44   {
  45   }
  46
  47   bool Load(const Vector<uint8_t>& data, float dpi)
  48   {
  49     if(strncmp(reinterpret_cast<char*>(data.Begin()), "invalid", 7) == 0)
  50     {
  51       return false;
  52     }
  53     else if(strncmp(reinterpret_cast<char*>(data.Begin()), "Fail to rasterize", strlen("Fail to rasterize")) == 0)
  54     {
  55       mRasterizeSuccess = false;
  56     }
  57     return true;
  58   }
  59
  60   Dali::Devel::PixelBuffer Rasterize(uint32_t width, uint32_t height)
  61   {
  62     if(mRasterizeSuccess)
  63     {
  64       Devel::PixelBuffer pixelBuffer = Devel::PixelBuffer::New(width, height, Dali::Pixel::RGBA8888);
  65       return pixelBuffer;
  66     }
  67     return Dali::Devel::PixelBuffer();
  68   }
  69
  70   void GetDefaultSize(uint32_t& width, uint32_t& height) const
  71   {
  72     width  = 100;
  73     height = 100;
  74   }
  75
  76 public:
  77   uint32_t mWidth;
  78   uint32_t mHeight;
  79   bool     mRasterizeSuccess;
  80 };
  81
  82 inline VectorImageRenderer& GetImplementation(Dali::VectorImageRenderer& renderer)
  83 {
  84   DALI_ASSERT_ALWAYS(renderer && "VectorImageRenderer handle is empty.");
  85   BaseObject& handle = renderer.GetBaseObject();
  86   return static_cast<Internal::Adaptor::VectorImageRenderer&>(handle);
  87 }
  88
  89 inline const VectorImageRenderer& GetImplementation(const Dali::VectorImageRenderer& renderer)
  90 {
  91   DALI_ASSERT_ALWAYS(renderer && "VectorImageRenderer handle is empty.");
  92   const BaseObject& handle = renderer.GetBaseObject();
  93   return static_cast<const Internal::Adaptor::VectorImageRenderer&>(handle);
  94 }
  95
  96 } // namespace Adaptor
  97
  98 } // namespace Internal
  99
 100 /********************************************************************************/
 101 /*********************************  PUBLIC CLASS  *******************************/
 102 /********************************************************************************/
 103
 104 VectorImageRenderer VectorImageRenderer::New()
 105 {
 106   Internal::Adaptor::VectorImageRenderer* imageRenderer = new Internal::Adaptor::VectorImageRenderer();
 107
 108   return VectorImageRenderer(imageRenderer);
 109 }
 110
 111 VectorImageRenderer::VectorImageRenderer()
 112 {
 113 }
 114
 115 VectorImageRenderer::~VectorImageRenderer()
 116 {
 117 }
 118
 119 VectorImageRenderer::VectorImageRenderer(Internal::Adaptor::VectorImageRenderer* internal)
 120 : BaseHandle(internal)
 121 {
 122 }
 123
 124 bool VectorImageRenderer::Load(const Vector<uint8_t>& data, float dpi)
 125 {
 126   return Internal::Adaptor::GetImplementation(*this).Load(data, dpi);
 127 }
 128
 129 Dali::Devel::PixelBuffer VectorImageRenderer::Rasterize(uint32_t width, uint32_t height)
 130 {
 131   return Internal::Adaptor::GetImplementation(*this).Rasterize(width, height);
 132 }
 133
 134 void VectorImageRenderer::GetDefaultSize(uint32_t& width, uint32_t& height) const
 135 {
 136   Internal::Adaptor::GetImplementation(*this).GetDefaultSize(width, height);
 137 }
 138
 139 } // namespace Dali