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     if( ! image )
 216     {
 217       // If the image is empty, then reset the renderer and return
 218       renderer.RemoveAndReset( actor );
 219       return;
 220     }
 221
 222     NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 223     if( npatchImage )
 224     {
 225       NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 226       if( rendererPtr )
 227       {
 228         rendererPtr->SetImage( npatchImage );
 229         return;
 230       }
 231     }
 232     else
 233     {
 234       ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 235       if( rendererPtr )
 236       {
 237         rendererPtr->SetImage( actor, image );
 238         return;
 239       }
 240     }
 241
 242     renderer.RemoveAndReset( actor );
 243   }
 244
 245   renderer = GetControlRenderer( image );
 246   if( actor && actor.OnStage() )
 247   {
 248     renderer.SetOnStage( actor );
 249   }
 250 }
 251
 252 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const std::string& url, ImageDimensions size )
 253 {
 254   if( !mFactoryCache )
 255   {
 256     mFactoryCache = new RendererFactoryCache();
 257   }
 258
 259   if( NinePatchImage::IsNinePatchUrl( url ) )
 260   {
 261     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 262     rendererPtr->SetImage( url );
 263
 264     return Toolkit::ControlRenderer( rendererPtr );
 265   }
 266   else
 267   {
 268     CreateAtlasManager();
 269     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 270     Actor actor;
 271     rendererPtr->SetImage( actor, url, size );
 272
 273     return Toolkit::ControlRenderer( rendererPtr );
 274   }
 275 }
 276
 277 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const std::string& url, ImageDimensions size )
 278 {
 279   if( renderer )
 280   {
 281     if( url.empty() )
 282     {
 283       // If the URL is empty, then reset the renderer and return
 284       renderer.RemoveAndReset( actor );
 285       return;
 286     }
 287     else if( NinePatchImage::IsNinePatchUrl( url ) )
 288     {
 289       NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 290       if( rendererPtr )
 291       {
 292         rendererPtr->SetImage( url );
 293         return;
 294       }
 295     }
 296     else
 297     {
 298       ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 299       if( rendererPtr )
 300       {
 301         rendererPtr->SetImage( actor, url, size );
 302         return;
 303       }
 304     }
 305
 306     renderer.RemoveAndReset( actor );
 307   }
 308
 309   renderer = GetControlRenderer( url, size );
 310   if( actor && actor.OnStage() )
 311   {
 312     renderer.SetOnStage( actor );
 313   }
 314 }
 315
 316 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap )
 317 {
 318   if( renderer )
 319   {
 320     ControlRenderer& controlRenderer = GetImplementation( renderer );
 321
 322     Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
 323     std::string typeValue ;
 324
 325     //If there's no renderer type specified or if there hasn't been a renderer type change then we can reuse the renderer
 326     if( !type || !type->Get( typeValue ) ||
 327         ( typeValue ==  IMAGE_RENDERER    && typeid( controlRenderer ) == typeid( ImageRenderer ) ) ||
 328         ( typeValue ==  N_PATCH_RENDERER  && typeid( controlRenderer ) == typeid( NPatchRenderer ) ) ||
 329         ( typeValue ==  COLOR_RENDERER    && typeid( controlRenderer ) == typeid( ColorRenderer ) )||
 330         ( typeValue ==  GRADIENT_RENDERER && typeid( controlRenderer ) == typeid( GradientRenderer ) ) ||
 331         ( typeValue ==  BORDER_RENDERER   && typeid( controlRenderer ) == typeid( BorderRenderer ) ) )
 332     {
 333       controlRenderer.Initialize( actor, propertyMap );
 334       return;
 335     }
 336
 337     renderer.RemoveAndReset( actor );
 338   }
 339
 340   renderer = GetControlRenderer( propertyMap );
 341   if( actor && actor.OnStage() )
 342   {
 343     renderer.SetOnStage( actor );
 344   }
 345 }
 346
 347 Image RendererFactory::GetBrokenRendererImage()
 348 {
 349   return ResourceImage::New( BROKEN_RENDERER_IMAGE_URL );
 350 }
 351
 352 void RendererFactory::CreateAtlasManager()
 353 {
 354   if( !mAtlasManager )
 355   {
 356     Shader shader = ImageRenderer::GetImageShader( *( mFactoryCache.Get() ) );
 357     mAtlasManager = new ImageAtlasManager(shader, TEXTURE_UNIFORM_NAME);
 358     mAtlasManager->SetBrokenImage( BROKEN_RENDERER_IMAGE_URL );
 359   }
 360 }
 361
 362 } // namespace Internal
 363
 364 } // namespace Toolkit
 365
 366 } // namespace Dali
 367