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/canvas-view/canvas-view.h>
  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_TYPE_REGISTRATION_END()
  49 } // anonymous namespace
  50
  51 using namespace Dali;
  52
  53 CanvasView::CanvasView(const Vector2& viewBox)
  54 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
  55   mCanvasRenderer(CanvasRenderer::New(viewBox)),
  56   mTexture(),
  57   mChanged(false)
  58 {
  59 }
  60
  61 CanvasView::~CanvasView()
  62 {
  63   if(Adaptor::IsAvailable())
  64   {
  65     Adaptor::Get().UnregisterProcessor(*this);
  66   }
  67 }
  68
  69 Toolkit::CanvasView CanvasView::New(const Vector2& viewBox)
  70 {
  71   CanvasView* impl = new CanvasView(viewBox);
  72
  73   Toolkit::CanvasView handle = Toolkit::CanvasView(*impl);
  74
  75   // Second-phase init of the implementation
  76   // This can only be done after the CustomActor connection has been made...
  77   impl->Initialize();
  78
  79   return handle;
  80 }
  81
  82 /////////////////////////////////////////////////////////////
  83
  84 void CanvasView::OnInitialize()
  85 {
  86   // CanvasView can relayout in the OnImageReady, alternative to a signal would be to have a upcall from the Control to CanvasView
  87   Dali::Toolkit::Control handle(GetOwner());
  88
  89   DevelControl::SetAccessibilityConstructor(Self(), [](Dali::Actor actor) {
  90     return std::unique_ptr<Dali::Accessibility::Accessible>(
  91       new DevelControl::AccessibleImpl(actor, Dali::Accessibility::Role::IMAGE));
  92   });
  93
  94   Self().SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
  95
  96   Adaptor::Get().RegisterProcessor(*this);
  97 }
  98
  99 void CanvasView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 100 {
 101   if(!mCanvasRenderer ||
 102      mCanvasRenderer.GetSize() == size ||
 103      !mCanvasRenderer.SetSize(size))
 104   {
 105     return;
 106   }
 107   mChanged = true;
 108 }
 109
 110 void CanvasView::OnSizeSet(const Vector3& targetSize)
 111 {
 112   Control::OnSizeSet(targetSize);
 113
 114   if(!mCanvasRenderer ||
 115      mCanvasRenderer.GetSize() == Vector2(targetSize) ||
 116      !mCanvasRenderer.SetSize(Vector2(targetSize)))
 117   {
 118     return;
 119   }
 120   mChanged = true;
 121 }
 122
 123 void CanvasView::Process()
 124 {
 125   if(!mCanvasRenderer)
 126   {
 127     return;
 128   }
 129   Commit();
 130 }
 131
 132 void CanvasView::Commit()
 133 {
 134   if(mCanvasRenderer && mCanvasRenderer.Commit())
 135   {
 136     Devel::PixelBuffer pixbuf = mCanvasRenderer.GetPixelBuffer();
 137     auto               width  = pixbuf.GetWidth();
 138     auto               height = pixbuf.GetHeight();
 139
 140     Dali::PixelData pixelData = Devel::PixelBuffer::Convert(pixbuf);
 141     if(!pixelData)
 142     {
 143       return;
 144     }
 145
 146     if(!mTexture || mChanged)
 147     {
 148       mTexture = Texture::New(TextureType::TEXTURE_2D, Dali::Pixel::RGBA8888, width, height);
 149       mTexture.Upload(pixelData);
 150       TextureSet textureSet = TextureSet::New();
 151       textureSet.SetTexture(0, mTexture);
 152       Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
 153       Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, SHADER_CANVAS_VIEW_FRAG);
 154       Renderer renderer = Renderer::New(geometry, shader);
 155       renderer.SetTextures(textureSet);
 156       renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
 157
 158       Self().AddRenderer(renderer);
 159       mChanged = false;
 160     }
 161     else
 162     {
 163       //Update texture
 164       mTexture.Upload(pixelData);
 165     }
 166   }
 167 }
 168
 169 bool CanvasView::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
 170 {
 171   if(mCanvasRenderer && mCanvasRenderer.AddDrawable(drawable))
 172   {
 173     return true;
 174   }
 175   return false;
 176 }
 177 } // namespace Internal
 178 } // namespace Toolkit
 179 } // namespace Dali