dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp

   1 /*
   2  * Copyright (c) 2023 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 // CLASS HEADER
  19 #include "canvas-view-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/rendering/texture-devel.h>
  23 #include <dali/devel-api/scripting/scripting.h>
  24 #include <dali/integration-api/adaptor-framework/adaptor.h>
  25 #include <dali/public-api/object/type-registry-helper.h>
  26 #include <dali/public-api/object/type-registry.h>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali-toolkit/devel-api/controls/control-devel.h>
  30 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  31 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
  32 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  33
  34 namespace Dali
  35 {
  36 namespace Toolkit
  37 {
  38 namespace Internal
  39 {
  40 namespace
  41 {
  42 BaseHandle Create()
  43 {
  44   return BaseHandle();
  45 }
  46 // Setup properties, signals and actions using the type-registry.
  47 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::CanvasView, Toolkit::Control, Create);
  48 DALI_PROPERTY_REGISTRATION(Toolkit, CanvasView, "viewBox", VECTOR2, VIEW_BOX)
  49 DALI_TYPE_REGISTRATION_END()
  50 } // anonymous namespace
  51
  52 using namespace Dali;
  53
  54 CanvasView::CanvasView(const Vector2& viewBox)
  55 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
  56   mCanvasRenderer(CanvasRenderer::New(viewBox)),
  57   mTexture(),
  58   mTextureSet(),
  59   mSize(viewBox)
  60 {
  61 }
  62
  63 CanvasView::~CanvasView()
  64 {
  65   if(Adaptor::IsAvailable())
  66   {
  67     Dali::AsyncTaskManager::Get().RemoveTask(mRasterizingTask);
  68     mRasterizingTask.Reset();
  69     Adaptor::Get().UnregisterProcessor(*this, true);
  70   }
  71 }
  72
  73 Toolkit::CanvasView CanvasView::New(const Vector2& viewBox)
  74 {
  75   CanvasView* impl = new CanvasView(viewBox);
  76
  77   Toolkit::CanvasView handle = Toolkit::CanvasView(*impl);
  78
  79   // Second-phase init of the implementation
  80   // This can only be done after the CustomActor connection has been made...
  81   impl->Initialize();
  82
  83   return handle;
  84 }
  85
  86 /////////////////////////////////////////////////////////////
  87
  88 void CanvasView::OnInitialize()
  89 {
  90   // CanvasView can relayout in the OnImageReady, alternative to a signal would be to have a upcall from the Control to CanvasView
  91   Dali::Toolkit::Control handle(GetOwner());
  92
  93   Self().SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::IMAGE);
  94
  95   Adaptor::Get().RegisterProcessor(*this, true);
  96 }
  97
  98 void CanvasView::OnRelayout(const Vector2& size, RelayoutContainer& container)
  99 {
 100   if(!mCanvasRenderer ||
 101      !mCanvasRenderer.SetSize(size))
 102   {
 103     return;
 104   }
 105   mSize = size;
 106 }
 107
 108 void CanvasView::OnSizeSet(const Vector3& targetSize)
 109 {
 110   Control::OnSizeSet(targetSize);
 111
 112   if(!mCanvasRenderer ||
 113      !mCanvasRenderer.SetSize(Vector2(targetSize)))
 114   {
 115     return;
 116   }
 117   mSize.width  = targetSize.width;
 118   mSize.height = targetSize.height;
 119 }
 120
 121 void CanvasView::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 122 {
 123   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 124   if(canvasView)
 125   {
 126     CanvasView& canvasViewImpl(GetImpl(canvasView));
 127
 128     switch(propertyIndex)
 129     {
 130       case Toolkit::CanvasView::Property::VIEW_BOX:
 131       {
 132         Vector2 valueVector2;
 133         if(value.Get(valueVector2))
 134         {
 135           canvasViewImpl.SetViewBox(valueVector2);
 136         }
 137         break;
 138       }
 139     }
 140   }
 141 }
 142
 143 Property::Value CanvasView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 144 {
 145   Property::Value value;
 146
 147   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 148
 149   if(canvasView)
 150   {
 151     CanvasView& canvasViewImpl(GetImpl(canvasView));
 152
 153     switch(propertyIndex)
 154     {
 155       case Toolkit::CanvasView::Property::VIEW_BOX:
 156       {
 157         value = canvasViewImpl.GetViewBox();
 158         break;
 159       }
 160     }
 161   }
 162   return value;
 163 }
 164
 165 void CanvasView::Process(bool postProcessor)
 166 {
 167   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged() && mSize.width > 0 && mSize.height > 0)
 168   {
 169     AddRasterizationTask();
 170   }
 171 }
 172
 173 void CanvasView::AddRasterizationTask()
 174 {
 175   mRasterizingTask = new CanvasRendererRasterizingTask(mCanvasRenderer, MakeCallback(this, &CanvasView::ApplyRasterizedImage));
 176
 177   if(mCanvasRenderer.Commit())
 178   {
 179     AsyncTaskManager::Get().AddTask(mRasterizingTask);
 180   }
 181 }
 182
 183 void CanvasView::ApplyRasterizedImage(CanvasRendererRasterizingTaskPtr task)
 184 {
 185   if(task->IsRasterized())
 186   {
 187     Texture rasterizedTexture = task->GetRasterizedTexture();
 188     if(rasterizedTexture && rasterizedTexture.GetWidth() != 0 && rasterizedTexture.GetHeight() != 0)
 189     {
 190       if(!mTextureSet)
 191       {
 192         std::string fragmentShader = SHADER_CANVAS_VIEW_FRAG.data();
 193         DevelTexture::ApplyNativeFragmentShader(rasterizedTexture, fragmentShader);
 194
 195         mTextureSet       = TextureSet::New();
 196         Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
 197         Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, fragmentShader);
 198         Renderer renderer = Renderer::New(geometry, shader);
 199
 200         renderer.SetTextures(mTextureSet);
 201         renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
 202         Self().AddRenderer(renderer);
 203       }
 204       mTextureSet.SetTexture(0, rasterizedTexture);
 205     }
 206   }
 207
 208   mRasterizingTask.Reset(); // We don't need it anymore
 209
 210   //If there are accumulated changes to CanvasRenderer during Rasterize, Rasterize once again.
 211   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged())
 212   {
 213     AddRasterizationTask();
 214   }
 215 }
 216
 217 bool CanvasView::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
 218 {
 219   if(mCanvasRenderer && mCanvasRenderer.AddDrawable(drawable))
 220   {
 221     return true;
 222   }
 223   return false;
 224 }
 225
 226 bool CanvasView::RemoveDrawable(Dali::CanvasRenderer::Drawable& drawable)
 227 {
 228   if(mCanvasRenderer && mCanvasRenderer.RemoveDrawable(drawable))
 229   {
 230     return true;
 231   }
 232   return false;
 233 }
 234
 235 bool CanvasView::RemoveAllDrawables()
 236 {
 237   if(mCanvasRenderer && mCanvasRenderer.RemoveAllDrawables())
 238   {
 239     return true;
 240   }
 241   return false;
 242 }
 243
 244 bool CanvasView::SetViewBox(const Vector2& viewBox)
 245 {
 246   if(mCanvasRenderer && mCanvasRenderer.SetViewBox(viewBox))
 247   {
 248     return true;
 249   }
 250   return false;
 251 }
 252
 253 const Vector2& CanvasView::GetViewBox()
 254 {
 255   if(mCanvasRenderer)
 256   {
 257     return mCanvasRenderer.GetViewBox();
 258   }
 259   return Vector2::ZERO;
 260 }
 261 } // namespace Internal
 262 } // namespace Toolkit
 263 } // namespace Dali