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);
 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(PixelData rasterizedPixelData)
 200 {
 201   if(rasterizedPixelData)
 202   {
 203     auto rasterizedPixelDataWidth  = rasterizedPixelData.GetWidth();
 204     auto rasterizedPixelDataHeight = rasterizedPixelData.GetHeight();
 205
 206     if(rasterizedPixelDataWidth > 0 && rasterizedPixelDataHeight > 0)
 207     {
 208       if(!mTexture || mTexture.GetWidth() != rasterizedPixelDataWidth || mTexture.GetHeight() != rasterizedPixelDataHeight)
 209       {
 210         mTexture = Texture::New(TextureType::TEXTURE_2D, Dali::Pixel::RGBA8888, rasterizedPixelDataWidth, rasterizedPixelDataHeight);
 211         mTexture.Upload(rasterizedPixelData);
 212
 213         if(!mTextureSet)
 214         {
 215           mTextureSet       = TextureSet::New();
 216           Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
 217           Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, SHADER_CANVAS_VIEW_FRAG);
 218           Renderer renderer = Renderer::New(geometry, shader);
 219           renderer.SetTextures(mTextureSet);
 220           renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
 221
 222           Actor actor = Self();
 223           if(actor)
 224           {
 225             actor.AddRenderer(renderer);
 226           }
 227         }
 228         mTextureSet.SetTexture(0, mTexture);
 229       }
 230       else
 231       {
 232         //Update texture
 233         mTexture.Upload(rasterizedPixelData);
 234       }
 235     }
 236   }
 237
 238   //If there are accumulated changes to CanvasRenderer during Rasterize, Rasterize once again.
 239   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged())
 240   {
 241     AddRasterizationTask();
 242   }
 243 }
 244
 245 bool CanvasView::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
 246 {
 247   if(mCanvasRenderer && mCanvasRenderer.AddDrawable(drawable))
 248   {
 249     return true;
 250   }
 251   return false;
 252 }
 253
 254 bool CanvasView::SetViewBox(const Vector2& viewBox)
 255 {
 256   if(mCanvasRenderer && mCanvasRenderer.SetViewBox(viewBox))
 257   {
 258     return true;
 259   }
 260   return false;
 261 }
 262
 263 const Vector2& CanvasView::GetViewBox()
 264 {
 265   if(mCanvasRenderer)
 266   {
 267     return mCanvasRenderer.GetViewBox();
 268   }
 269   return Vector2::ZERO;
 270 }
 271 } // namespace Internal
 272 } // namespace Toolkit
 273 } // namespace Dali