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

   1 /*
   2  * Copyright (c) 2024 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_PROPERTY_REGISTRATION(Toolkit, CanvasView, "synchronousLoading", BOOLEAN, SYNCHRONOUS_LOADING)
  50 DALI_TYPE_REGISTRATION_END()
  51 } // anonymous namespace
  52
  53 using namespace Dali;
  54
  55 CanvasView::CanvasView(const Vector2& viewBox)
  56 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
  57   mCanvasRenderer(CanvasRenderer::New(viewBox)),
  58   mTexture(),
  59   mTextureSet(),
  60   mSize(viewBox),
  61   mIsSynchronous(true)
  62 {
  63 }
  64
  65 CanvasView::~CanvasView()
  66 {
  67   if(Adaptor::IsAvailable())
  68   {
  69     Dali::AsyncTaskManager::Get().RemoveTask(mRasterizingTask);
  70     mRasterizingTask.Reset();
  71     Adaptor::Get().UnregisterProcessor(*this, true);
  72   }
  73 }
  74
  75 Toolkit::CanvasView CanvasView::New(const Vector2& viewBox)
  76 {
  77   CanvasView* impl = new CanvasView(viewBox);
  78
  79   Toolkit::CanvasView handle = Toolkit::CanvasView(*impl);
  80
  81   // Second-phase init of the implementation
  82   // This can only be done after the CustomActor connection has been made...
  83   impl->Initialize();
  84
  85   return handle;
  86 }
  87
  88 /////////////////////////////////////////////////////////////
  89
  90 void CanvasView::OnInitialize()
  91 {
  92   // CanvasView can relayout in the OnImageReady, alternative to a signal would be to have a upcall from the Control to CanvasView
  93   Dali::Toolkit::Control handle(GetOwner());
  94
  95   Self().SetProperty(DevelControl::Property::ACCESSIBILITY_ROLE, Dali::Accessibility::Role::IMAGE);
  96
  97   Adaptor::Get().RegisterProcessor(*this, true);
  98 }
  99
 100 void CanvasView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 101 {
 102   if(!mCanvasRenderer ||
 103      !mCanvasRenderer.SetSize(size))
 104   {
 105     return;
 106   }
 107   mSize = size;
 108 }
 109
 110 void CanvasView::OnSizeSet(const Vector3& targetSize)
 111 {
 112   Control::OnSizeSet(targetSize);
 113
 114   if(!mCanvasRenderer ||
 115      !mCanvasRenderer.SetSize(Vector2(targetSize)))
 116   {
 117     return;
 118   }
 119   mSize.width  = targetSize.width;
 120   mSize.height = targetSize.height;
 121 }
 122
 123 void CanvasView::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 124 {
 125   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 126   if(canvasView)
 127   {
 128     CanvasView& canvasViewImpl(GetImpl(canvasView));
 129
 130     switch(propertyIndex)
 131     {
 132       case Toolkit::CanvasView::Property::VIEW_BOX:
 133       {
 134         Vector2 valueVector2;
 135         if(value.Get(valueVector2))
 136         {
 137           canvasViewImpl.SetViewBox(valueVector2);
 138         }
 139         break;
 140       }
 141       case Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING:
 142       {
 143         bool isSynchronous;
 144         if(value.Get(isSynchronous))
 145         {
 146           canvasViewImpl.SetSynchronous(isSynchronous);
 147         }
 148         break;
 149       }
 150     }
 151   }
 152 }
 153
 154 Property::Value CanvasView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 155 {
 156   Property::Value value;
 157
 158   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 159
 160   if(canvasView)
 161   {
 162     CanvasView& canvasViewImpl(GetImpl(canvasView));
 163
 164     switch(propertyIndex)
 165     {
 166       case Toolkit::CanvasView::Property::VIEW_BOX:
 167       {
 168         value = canvasViewImpl.GetViewBox();
 169         break;
 170       }
 171       case Toolkit::CanvasView::Property::SYNCHRONOUS_LOADING:
 172       {
 173         value = canvasViewImpl.IsSynchronous();
 174         break;
 175       }
 176     }
 177   }
 178   return value;
 179 }
 180
 181 void CanvasView::Process(bool postProcessor)
 182 {
 183   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged() && mSize.width > 0 && mSize.height > 0)
 184   {
 185     AddRasterizationTask();
 186   }
 187 }
 188
 189 void CanvasView::AddRasterizationTask()
 190 {
 191   mRasterizingTask = new CanvasRendererRasterizingTask(mCanvasRenderer, MakeCallback(this, &CanvasView::ApplyRasterizedImage));
 192
 193   if(mCanvasRenderer.Commit())
 194   {
 195     if(mIsSynchronous)
 196     {
 197       mRasterizingTask->Process();
 198       ApplyRasterizedImage(mRasterizingTask);
 199       mRasterizingTask.Reset(); // We don't need it anymore.
 200     }
 201     else
 202     {
 203       AsyncTaskManager::Get().AddTask(mRasterizingTask);
 204     }
 205   }
 206 }
 207
 208 void CanvasView::ApplyRasterizedImage(CanvasRendererRasterizingTaskPtr task)
 209 {
 210   if(task->IsRasterized())
 211   {
 212     Texture rasterizedTexture = task->GetRasterizedTexture();
 213     if(rasterizedTexture && rasterizedTexture.GetWidth() != 0 && rasterizedTexture.GetHeight() != 0)
 214     {
 215       if(!mTextureSet)
 216       {
 217         std::string fragmentShader = SHADER_CANVAS_VIEW_FRAG.data();
 218         DevelTexture::ApplyNativeFragmentShader(rasterizedTexture, fragmentShader);
 219
 220         mTextureSet       = TextureSet::New();
 221         Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
 222         Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, fragmentShader, Shader::Hint::NONE, "CANVAS_VIEW");
 223         Renderer renderer = Renderer::New(geometry, shader);
 224
 225         renderer.SetTextures(mTextureSet);
 226         renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
 227         Self().AddRenderer(renderer);
 228       }
 229       mTextureSet.SetTexture(0, rasterizedTexture);
 230     }
 231   }
 232
 233   mRasterizingTask.Reset(); // We don't need it anymore
 234
 235   //If there are accumulated changes to CanvasRenderer during Rasterize, Rasterize once again.
 236   if(!mIsSynchronous && mCanvasRenderer && mCanvasRenderer.IsCanvasChanged())
 237   {
 238     AddRasterizationTask();
 239   }
 240 }
 241
 242 bool CanvasView::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
 243 {
 244   if(mCanvasRenderer && mCanvasRenderer.AddDrawable(drawable))
 245   {
 246     return true;
 247   }
 248   return false;
 249 }
 250
 251 bool CanvasView::RemoveDrawable(Dali::CanvasRenderer::Drawable& drawable)
 252 {
 253   if(mCanvasRenderer && mCanvasRenderer.RemoveDrawable(drawable))
 254   {
 255     return true;
 256   }
 257   return false;
 258 }
 259
 260 bool CanvasView::RemoveAllDrawables()
 261 {
 262   if(mCanvasRenderer && mCanvasRenderer.RemoveAllDrawables())
 263   {
 264     return true;
 265   }
 266   return false;
 267 }
 268
 269 bool CanvasView::SetViewBox(const Vector2& viewBox)
 270 {
 271   if(mCanvasRenderer && mCanvasRenderer.SetViewBox(viewBox))
 272   {
 273     return true;
 274   }
 275   return false;
 276 }
 277
 278 const Vector2& CanvasView::GetViewBox()
 279 {
 280   if(mCanvasRenderer)
 281   {
 282     return mCanvasRenderer.GetViewBox();
 283   }
 284   return Vector2::ZERO;
 285 }
 286
 287 void CanvasView::SetSynchronous(const bool isSynchronous)
 288 {
 289   mIsSynchronous = isSynchronous;
 290 }
 291
 292 const bool CanvasView::IsSynchronous()
 293 {
 294   return mIsSynchronous;
 295 }
 296
 297 } // namespace Internal
 298 } // namespace Toolkit
 299 } // namespace Dali