dali-toolkit/internal/controls/renderers/renderer-factory-impl.cpp

   1  /*
   2  * Copyright (c) 2015 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 // CLASS HEADER
  18 #include "renderer-factory-impl.h"
  19
  20 // EXTERNAL INCLUDES
  21 #include <dali/integration-api/debug.h>
  22 #include <dali/public-api/images/image.h>
  23 #include <dali/public-api/object/property-array.h>
  24 #include <dali/public-api/object/type-registry.h>
  25 #include <dali/devel-api/object/type-registry-helper.h>
  26
  27 // Internal HEADER
  28 #include <dali-toolkit/internal/controls/renderers/border/border-renderer.h>
  29 #include <dali-toolkit/internal/controls/renderers/color/color-renderer.h>
  30 #include <dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h>
  31 #include <dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.h>
  32 #include <dali-toolkit/internal/controls/renderers/image/image-renderer.h>
  33 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
  34 #include <dali-toolkit/internal/controls/renderers/image-atlas-manager.h>
  35
  36 namespace
  37 {
  38 const char * const RENDERER_TYPE_NAME( "rendererType" );
  39
  40 const char * const COLOR_RENDERER("colorRenderer");
  41 const char * const BORDER_RENDERER("borderRenderer");
  42 const char * const GRADIENT_RENDERER("gradientRenderer");
  43 const char * const IMAGE_RENDERER("imageRenderer");
  44 const char * const N_PATCH_RENDERER("nPatchRenderer");
  45
  46 const std::string TEXTURE_UNIFORM_NAME = "sTexture";
  47
  48 const char * const BROKEN_RENDERER_IMAGE_URL( DALI_IMAGE_DIR "broken.png");
  49 }
  50
  51 namespace Dali
  52 {
  53
  54 namespace Toolkit
  55 {
  56
  57 namespace Internal
  58 {
  59
  60 namespace
  61 {
  62
  63 BaseHandle Create()
  64 {
  65   BaseHandle handle = Toolkit::RendererFactory::Get();
  66
  67   return handle;
  68 }
  69
  70 DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::RendererFactory, Dali::BaseHandle, Create, true )
  71 DALI_TYPE_REGISTRATION_END()
  72
  73 } // namespace
  74
  75 RendererFactory::RendererFactory()
  76 {
  77 }
  78
  79 RendererFactory::~RendererFactory()
  80 {
  81 }
  82
  83 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Property::Map& propertyMap )
  84 {
  85   ControlRenderer* rendererPtr = NULL;
  86
  87   Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
  88   std::string typeValue ;
  89   if( type && type->Get( typeValue ))
  90   {
  91     if( !mFactoryCache )
  92     {
  93       mFactoryCache = new RendererFactoryCache();
  94     }
  95
  96     if( typeValue ==  COLOR_RENDERER )
  97     {
  98       rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );
  99     }
 100     else if( typeValue ==  GRADIENT_RENDERER )
 101     {
 102       rendererPtr = new GradientRenderer( *( mFactoryCache.Get() ) );
 103     }
 104     else if( typeValue ==  IMAGE_RENDERER )
 105     {
 106       CreateAtlasManager();
 107       rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 108     }
 109     else if( typeValue ==  N_PATCH_RENDERER )
 110     {
 111       rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 112     }
 113     else if( typeValue == BORDER_RENDERER )
 114     {
 115       rendererPtr = new BorderRenderer( *( mFactoryCache.Get() ) );
 116     }
 117   }
 118
 119   if( rendererPtr )
 120   {
 121     Actor actor;
 122     rendererPtr->Initialize( actor, propertyMap );
 123   }
 124   else
 125   {
 126     DALI_LOG_ERROR( "Renderer type unknown" );
 127   }
 128
 129   return Toolkit::ControlRenderer( rendererPtr );
 130 }
 131
 132 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
 133 {
 134   if( !mFactoryCache )
 135   {
 136     mFactoryCache = new RendererFactoryCache();
 137   }
 138
 139   ColorRenderer* rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );
 140   rendererPtr->SetColor( color );
 141
 142   return Toolkit::ControlRenderer( rendererPtr );
 143 }
 144
 145 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Vector4& color )
 146 {
 147   if( renderer )
 148   {
 149     ColorRenderer* rendererPtr = dynamic_cast< ColorRenderer* >( &GetImplementation( renderer ) );
 150     if( rendererPtr )
 151     {
 152       rendererPtr->SetColor( color );
 153       return;
 154     }
 155
 156     renderer.RemoveAndReset( actor );
 157   }
 158
 159   renderer = GetControlRenderer( color );
 160   if( actor && actor.OnStage() )
 161   {
 162     renderer.SetOnStage( actor );
 163   }
 164 }
 165
 166 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( float borderSize, const Vector4& borderColor )
 167 {
 168   if( !mFactoryCache )
 169   {
 170     mFactoryCache = new RendererFactoryCache();
 171   }
 172   BorderRenderer* rendererPtr = new BorderRenderer( *mFactoryCache.Get() );
 173
 174   if( !mFactoryCache )
 175   {
 176     mFactoryCache = new RendererFactoryCache();
 177   }
 178
 179   rendererPtr->SetBorderSize( borderSize );
 180   rendererPtr->SetBorderColor( borderColor );
 181
 182   return Toolkit::ControlRenderer( rendererPtr );
 183 }
 184
 185 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Image& image )
 186 {
 187   if( !mFactoryCache )
 188   {
 189     mFactoryCache = new RendererFactoryCache();
 190   }
 191
 192   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 193   if( npatchImage )
 194   {
 195     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 196     rendererPtr->SetImage( npatchImage );
 197
 198     return Toolkit::ControlRenderer( rendererPtr );
 199   }
 200   else
 201   {
 202     CreateAtlasManager();
 203     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 204     Actor actor;
 205     rendererPtr->SetImage( actor, image );
 206
 207     return Toolkit::ControlRenderer( rendererPtr );
 208   }
 209 }
 210
 211 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Image& image )
 212 {
 213   if( renderer )
 214   {
 215     NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 216     if( npatchImage )
 217     {
 218       NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 219       if( rendererPtr )
 220       {
 221         rendererPtr->SetImage( npatchImage );
 222         return;
 223       }
 224     }
 225     else
 226     {
 227       ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 228       if( rendererPtr )
 229       {
 230         rendererPtr->SetImage( actor, image );
 231         return;
 232       }
 233     }
 234
 235     renderer.RemoveAndReset( actor );
 236   }
 237
 238   renderer = GetControlRenderer( image );
 239   if( actor && actor.OnStage() )
 240   {
 241     renderer.SetOnStage( actor );
 242   }
 243 }
 244
 245 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const std::string& url, ImageDimensions size )
 246 {
 247   if( !mFactoryCache )
 248   {
 249     mFactoryCache = new RendererFactoryCache();
 250   }
 251
 252   if( NinePatchImage::IsNinePatchUrl( url ) )
 253   {
 254     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 255     rendererPtr->SetImage( url );
 256
 257     return Toolkit::ControlRenderer( rendererPtr );
 258   }
 259   else
 260   {
 261     CreateAtlasManager();
 262     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 263     Actor actor;
 264     rendererPtr->SetImage( actor, url, size );
 265
 266     return Toolkit::ControlRenderer( rendererPtr );
 267   }
 268 }
 269
 270 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const std::string& url, ImageDimensions size )
 271 {
 272   if( renderer )
 273   {
 274     if( NinePatchImage::IsNinePatchUrl( url ) )
 275     {
 276       NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 277       if( rendererPtr )
 278       {
 279         rendererPtr->SetImage( url );
 280         return;
 281       }
 282     }
 283     else
 284     {
 285       ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 286       if( rendererPtr )
 287       {
 288         rendererPtr->SetImage( actor, url, size );
 289         return;
 290       }
 291     }
 292
 293     renderer.RemoveAndReset( actor );
 294   }
 295
 296   renderer = GetControlRenderer( url, size );
 297   if( actor && actor.OnStage() )
 298   {
 299     renderer.SetOnStage( actor );
 300   }
 301 }
 302
 303 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap )
 304 {
 305   if( renderer )
 306   {
 307     ControlRenderer& controlRenderer = GetImplementation( renderer );
 308
 309     Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
 310     std::string typeValue ;
 311
 312     //If there's no renderer type specified or if there hasn't been a renderer type change then we can reuse the renderer
 313     if( !type || !type->Get( typeValue ) ||
 314         ( typeValue ==  IMAGE_RENDERER    && typeid( controlRenderer ) == typeid( ImageRenderer ) ) ||
 315         ( typeValue ==  N_PATCH_RENDERER  && typeid( controlRenderer ) == typeid( NPatchRenderer ) ) ||
 316         ( typeValue ==  COLOR_RENDERER    && typeid( controlRenderer ) == typeid( ColorRenderer ) )||
 317         ( typeValue ==  GRADIENT_RENDERER && typeid( controlRenderer ) == typeid( GradientRenderer ) ) ||
 318         ( typeValue ==  BORDER_RENDERER   && typeid( controlRenderer ) == typeid( BorderRenderer ) ) )
 319     {
 320       controlRenderer.Initialize( actor, propertyMap );
 321       return;
 322     }
 323
 324     renderer.RemoveAndReset( actor );
 325   }
 326
 327   renderer = GetControlRenderer( propertyMap );
 328   if( actor && actor.OnStage() )
 329   {
 330     renderer.SetOnStage( actor );
 331   }
 332 }
 333
 334 Image RendererFactory::GetBrokenRendererImage()
 335 {
 336   return ResourceImage::New( BROKEN_RENDERER_IMAGE_URL );
 337 }
 338
 339 void RendererFactory::CreateAtlasManager()
 340 {
 341   if( !mAtlasManager )
 342   {
 343     Shader shader = ImageRenderer::GetImageShader( *( mFactoryCache.Get() ) );
 344     mAtlasManager = new ImageAtlasManager(shader, TEXTURE_UNIFORM_NAME);
 345     mAtlasManager->SetBrokenImage( BROKEN_RENDERER_IMAGE_URL );
 346   }
 347 }
 348
 349 } // namespace Internal
 350
 351 } // namespace Toolkit
 352
 353 } // namespace Dali
 354