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

   1 /*
   2  * Copyright (c) 2021 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/scripting/scripting.h>
  23 #include <dali/integration-api/adaptor-framework/adaptor.h>
  24 #include <dali/public-api/object/type-registry-helper.h>
  25 #include <dali/public-api/object/type-registry.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-toolkit/devel-api/controls/control-devel.h>
  29 #include <dali-toolkit/internal/controls/canvas-view/canvas-view-rasterize-thread.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   mCanvasViewRasterizeThread(nullptr)
  61 {
  62 }
  63
  64 CanvasView::~CanvasView()
  65 {
  66   if(mCanvasViewRasterizeThread)
  67   {
  68     mCanvasViewRasterizeThread->RemoveTask(this);
  69
  70     CanvasViewRasterizeThread::TerminateThread(mCanvasViewRasterizeThread);
  71   }
  72
  73   if(Adaptor::IsAvailable())
  74   {
  75     Adaptor::Get().UnregisterProcessor(*this);
  76   }
  77 }
  78
  79 Toolkit::CanvasView CanvasView::New(const Vector2& viewBox)
  80 {
  81   CanvasView* impl = new CanvasView(viewBox);
  82
  83   Toolkit::CanvasView handle = Toolkit::CanvasView(*impl);
  84
  85   // Second-phase init of the implementation
  86   // This can only be done after the CustomActor connection has been made...
  87   impl->Initialize();
  88
  89   return handle;
  90 }
  91
  92 /////////////////////////////////////////////////////////////
  93
  94 void CanvasView::OnInitialize()
  95 {
  96   // CanvasView can relayout in the OnImageReady, alternative to a signal would be to have a upcall from the Control to CanvasView
  97   Dali::Toolkit::Control handle(GetOwner());
  98
  99   DevelControl::SetAccessibilityConstructor(Self(), [](Dali::Actor actor) {
 100     return std::unique_ptr<Dali::Accessibility::Accessible>(
 101       new DevelControl::AccessibleImpl(actor, Dali::Accessibility::Role::IMAGE));
 102   });
 103
 104   Adaptor::Get().RegisterProcessor(*this, true);
 105 }
 106
 107 void CanvasView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 108 {
 109   if(!mCanvasRenderer ||
 110      !mCanvasRenderer.SetSize(size))
 111   {
 112     return;
 113   }
 114   mSize = size;
 115 }
 116
 117 void CanvasView::OnSizeSet(const Vector3& targetSize)
 118 {
 119   Control::OnSizeSet(targetSize);
 120
 121   if(!mCanvasRenderer ||
 122      !mCanvasRenderer.SetSize(Vector2(targetSize)))
 123   {
 124     return;
 125   }
 126   mSize.width  = targetSize.width;
 127   mSize.height = targetSize.height;
 128 }
 129
 130 void CanvasView::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 131 {
 132   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 133   if(canvasView)
 134   {
 135     CanvasView& canvasViewImpl(GetImpl(canvasView));
 136
 137     switch(propertyIndex)
 138     {
 139       case Toolkit::CanvasView::Property::VIEW_BOX:
 140       {
 141         Vector2 valueVector2;
 142         if(value.Get(valueVector2))
 143         {
 144           canvasViewImpl.SetViewBox(valueVector2);
 145         }
 146         break;
 147       }
 148     }
 149   }
 150 }
 151
 152 Property::Value CanvasView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 153 {
 154   Property::Value value;
 155
 156   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 157
 158   if(canvasView)
 159   {
 160     CanvasView& canvasViewImpl(GetImpl(canvasView));
 161
 162     switch(propertyIndex)
 163     {
 164       case Toolkit::CanvasView::Property::VIEW_BOX:
 165       {
 166         value = canvasViewImpl.GetViewBox();
 167         break;
 168       }
 169     }
 170   }
 171   return value;
 172 }
 173
 174 void CanvasView::Process(bool postProcessor)
 175 {
 176   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged() && mSize.width > 0 && mSize.height > 0)
 177   {
 178     AddRasterizationTask();
 179   }
 180 }
 181
 182 void CanvasView::AddRasterizationTask()
 183 {
 184   CanvasRendererRasterizingTaskPtr newTask = new CanvasRendererRasterizingTask(this, mCanvasRenderer);
 185
 186   if(!mCanvasViewRasterizeThread)
 187   {
 188     mCanvasViewRasterizeThread = new CanvasViewRasterizeThread();
 189     mCanvasViewRasterizeThread->RasterizationCompletedSignal().Connect(this, &CanvasView::ApplyRasterizedImage);
 190     mCanvasViewRasterizeThread->Start();
 191   }
 192
 193   if(mCanvasRenderer.Commit())
 194   {
 195     mCanvasViewRasterizeThread->AddTask(newTask);
 196   }
 197 }
 198
 199 void CanvasView::ApplyRasterizedImage(Texture rasterizedTexture)
 200 {
 201   if (rasterizedTexture && rasterizedTexture.GetWidth() != 0 && rasterizedTexture.GetHeight() != 0)
 202   {
 203     if(!mTextureSet)
 204     {
 205       mTextureSet       = TextureSet::New();
 206       Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
 207       Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, SHADER_CANVAS_VIEW_FRAG);
 208       Renderer renderer = Renderer::New(geometry, shader);
 209       renderer.SetTextures(mTextureSet);
 210       renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
 211       Self().AddRenderer(renderer);
 212     }
 213     mTextureSet.SetTexture(0, rasterizedTexture);
 214   }
 215
 216   //If there are accumulated changes to CanvasRenderer during Rasterize, Rasterize once again.
 217   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged())
 218   {
 219     AddRasterizationTask();
 220   }
 221 }
 222
 223 bool CanvasView::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
 224 {
 225   if(mCanvasRenderer && mCanvasRenderer.AddDrawable(drawable))
 226   {
 227     return true;
 228   }
 229   return false;
 230 }
 231
 232 bool CanvasView::RemoveDrawable(Dali::CanvasRenderer::Drawable& drawable)
 233 {
 234   if(mCanvasRenderer && mCanvasRenderer.RemoveDrawable(drawable))
 235   {
 236     return true;
 237   }
 238   return false;
 239 }
 240
 241 bool CanvasView::RemoveAllDrawables()
 242 {
 243   if(mCanvasRenderer && mCanvasRenderer.RemoveAllDrawables())
 244   {
 245     return true;
 246   }
 247   return false;
 248 }
 249
 250 bool CanvasView::SetViewBox(const Vector2& viewBox)
 251 {
 252   if(mCanvasRenderer && mCanvasRenderer.SetViewBox(viewBox))
 253   {
 254     return true;
 255   }
 256   return false;
 257 }
 258
 259 const Vector2& CanvasView::GetViewBox()
 260 {
 261   if(mCanvasRenderer)
 262   {
 263     return mCanvasRenderer.GetViewBox();
 264   }
 265   return Vector2::ZERO;
 266 }
 267 } // namespace Internal
 268 } // namespace Toolkit
 269 } // namespace Dali