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/debug/debug-renderer.h>
  31 #include <dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h>
  32 #include <dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.h>
  33 #include <dali-toolkit/internal/controls/renderers/image/image-renderer.h>
  34 #include <dali-toolkit/internal/controls/renderers/svg/svg-renderer.h>
  35 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
  36 #include <dali-toolkit/internal/controls/renderers/image-atlas-manager.h>
  37
  38 namespace
  39 {
  40 const char * const RENDERER_TYPE_NAME( "rendererType" );
  41
  42 const char * const COLOR_RENDERER("color");
  43 const char * const BORDER_RENDERER("border");
  44 const char * const GRADIENT_RENDERER("gradient");
  45 const char * const IMAGE_RENDERER("image");
  46 const char * const N_PATCH_RENDERER("nPatch");
  47 const char * const SVG_RENDERER("svg");
  48
  49 const std::string TEXTURE_UNIFORM_NAME = "sTexture";
  50
  51 const char * const BROKEN_RENDERER_IMAGE_URL( DALI_IMAGE_DIR "broken.png");
  52
  53 }
  54
  55 namespace Dali
  56 {
  57
  58 namespace Toolkit
  59 {
  60
  61 namespace Internal
  62 {
  63
  64 namespace
  65 {
  66
  67 BaseHandle Create()
  68 {
  69   BaseHandle handle = Toolkit::RendererFactory::Get();
  70
  71   return handle;
  72 }
  73
  74 DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::RendererFactory, Dali::BaseHandle, Create, true )
  75 DALI_TYPE_REGISTRATION_END()
  76
  77 } // namespace
  78
  79 RendererFactory::RendererFactory( bool debugEnabled )
  80 :mDebugEnabled( debugEnabled )
  81 {
  82 }
  83
  84 RendererFactory::~RendererFactory()
  85 {
  86 }
  87
  88 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Property::Map& propertyMap )
  89 {
  90   ControlRenderer* rendererPtr = NULL;
  91
  92   Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
  93   std::string typeValue ;
  94   if( type && type->Get( typeValue ))
  95   {
  96     if( !mFactoryCache )
  97     {
  98       mFactoryCache = new RendererFactoryCache();
  99     }
 100
 101     if( mDebugEnabled )
 102     {
 103       return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 104     }
 105
 106     if( typeValue ==  COLOR_RENDERER )
 107     {
 108       rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );
 109     }
 110     else if( typeValue ==  GRADIENT_RENDERER )
 111     {
 112       rendererPtr = new GradientRenderer( *( mFactoryCache.Get() ) );
 113     }
 114     else if( typeValue ==  IMAGE_RENDERER )
 115     {
 116       CreateAtlasManager();
 117       rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 118     }
 119     else if( typeValue ==  N_PATCH_RENDERER )
 120     {
 121       rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 122     }
 123     else if( typeValue == BORDER_RENDERER )
 124     {
 125       rendererPtr = new BorderRenderer( *( mFactoryCache.Get() ) );
 126     }
 127     else if( typeValue == SVG_RENDERER )
 128     {
 129       CreateAtlasManager();
 130       rendererPtr = new SvgRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 131     }
 132   }
 133
 134   if( rendererPtr )
 135   {
 136     Actor actor;
 137     rendererPtr->Initialize( actor, propertyMap );
 138   }
 139   else
 140   {
 141     DALI_LOG_ERROR( "Renderer type unknown" );
 142   }
 143
 144   return Toolkit::ControlRenderer( rendererPtr );
 145 }
 146
 147 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
 148 {
 149   if( !mFactoryCache )
 150   {
 151     mFactoryCache = new RendererFactoryCache();
 152   }
 153
 154   if( mDebugEnabled )
 155   {
 156     return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 157   }
 158
 159   ColorRenderer* rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );
 160   rendererPtr->SetColor( color );
 161
 162   return Toolkit::ControlRenderer( rendererPtr );
 163 }
 164
 165 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Vector4& color )
 166 {
 167   if( mDebugEnabled && renderer )
 168   {
 169     return;
 170   }
 171
 172   if( renderer )
 173   {
 174     ColorRenderer* rendererPtr = dynamic_cast< ColorRenderer* >( &GetImplementation( renderer ) );
 175     if( rendererPtr )
 176     {
 177       rendererPtr->SetColor( color );
 178       return;
 179     }
 180
 181     renderer.RemoveAndReset( actor );
 182   }
 183
 184   renderer = GetControlRenderer( color );
 185   if( actor && actor.OnStage() )
 186   {
 187     renderer.SetOnStage( actor );
 188   }
 189 }
 190
 191 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( float borderSize, const Vector4& borderColor, bool antiAliasing )
 192 {
 193   if( !mFactoryCache )
 194   {
 195     mFactoryCache = new RendererFactoryCache();
 196   }
 197
 198   if( mDebugEnabled )
 199   {
 200     return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 201   }
 202
 203   BorderRenderer* rendererPtr = new BorderRenderer( *mFactoryCache.Get() );
 204
 205   rendererPtr->SetBorderSize( borderSize );
 206   rendererPtr->SetBorderColor( borderColor );
 207   rendererPtr->RequireAntiAliasing( antiAliasing );
 208
 209   return Toolkit::ControlRenderer( rendererPtr );
 210 }
 211
 212 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Image& image )
 213 {
 214   if( !mFactoryCache )
 215   {
 216     mFactoryCache = new RendererFactoryCache();
 217   }
 218
 219   if( mDebugEnabled )
 220   {
 221     return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 222   }
 223
 224   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 225   if( npatchImage )
 226   {
 227     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 228     rendererPtr->SetImage( npatchImage );
 229
 230     return Toolkit::ControlRenderer( rendererPtr );
 231   }
 232   else
 233   {
 234     CreateAtlasManager();
 235     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 236     Actor actor;
 237     rendererPtr->SetImage( actor, image );
 238
 239     return Toolkit::ControlRenderer( rendererPtr );
 240   }
 241 }
 242
 243 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Image& image )
 244 {
 245   if( mDebugEnabled && renderer )
 246   {
 247     return;
 248   }
 249
 250   if( renderer )
 251   {
 252     if( ! image )
 253     {
 254       // If the image is empty, then reset the renderer and return
 255       renderer.RemoveAndReset( actor );
 256       return;
 257     }
 258
 259     NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 260     if( npatchImage )
 261     {
 262       NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 263       if( rendererPtr )
 264       {
 265         rendererPtr->SetImage( npatchImage );
 266         return;
 267       }
 268     }
 269     else
 270     {
 271       ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 272       if( rendererPtr )
 273       {
 274         rendererPtr->SetImage( actor, image );
 275         return;
 276       }
 277     }
 278
 279     renderer.RemoveAndReset( actor );
 280   }
 281
 282   renderer = GetControlRenderer( image );
 283   if( actor && actor.OnStage() )
 284   {
 285     renderer.SetOnStage( actor );
 286   }
 287 }
 288
 289 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const std::string& url, ImageDimensions size )
 290 {
 291   if( !mFactoryCache )
 292   {
 293     mFactoryCache = new RendererFactoryCache();
 294   }
 295
 296   if( mDebugEnabled )
 297   {
 298     return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 299   }
 300
 301   if( NinePatchImage::IsNinePatchUrl( url ) )
 302   {
 303     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 304     rendererPtr->SetImage( url );
 305
 306     return Toolkit::ControlRenderer( rendererPtr );
 307   }
 308   else if( SvgRenderer::IsSvgUrl( url ) )
 309   {
 310     CreateAtlasManager();
 311     SvgRenderer* rendererPtr = new SvgRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 312     rendererPtr->SetImage( url, size );
 313     return Toolkit::ControlRenderer( rendererPtr );
 314   }
 315   else
 316   {
 317     CreateAtlasManager();
 318     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 319     Actor actor;
 320     rendererPtr->SetImage( actor, url, size );
 321
 322     return Toolkit::ControlRenderer( rendererPtr );
 323   }
 324 }
 325
 326 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const std::string& url, ImageDimensions size )
 327 {
 328   if( mDebugEnabled && renderer )
 329   {
 330     return;
 331   }
 332
 333   if( renderer )
 334   {
 335     if( url.empty() )
 336     {
 337       // If the URL is empty, then reset the renderer and return
 338       renderer.RemoveAndReset( actor );
 339       return;
 340     }
 341     else if( NinePatchImage::IsNinePatchUrl( url ) )
 342     {
 343       NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 344       if( rendererPtr )
 345       {
 346         rendererPtr->SetImage( url );
 347         return;
 348       }
 349     }
 350     else if( SvgRenderer::IsSvgUrl( url ) )
 351     {
 352       SvgRenderer* rendererPtr = dynamic_cast< SvgRenderer* >( &GetImplementation( renderer ) );
 353       if( rendererPtr )
 354       {
 355         rendererPtr->SetImage( url, size );
 356         return;
 357       }
 358     }
 359     else
 360     {
 361       ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 362       if( rendererPtr )
 363       {
 364         rendererPtr->SetImage( actor, url, size );
 365         return;
 366       }
 367     }
 368
 369     renderer.RemoveAndReset( actor );
 370   }
 371
 372   renderer = GetControlRenderer( url, size );
 373   if( actor && actor.OnStage() )
 374   {
 375     renderer.SetOnStage( actor );
 376   }
 377 }
 378
 379 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap )
 380 {
 381   if( mDebugEnabled && renderer )
 382   {
 383     return;
 384   }
 385
 386   if( renderer )
 387   {
 388     ControlRenderer& controlRenderer = GetImplementation( renderer );
 389
 390     Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
 391     std::string typeValue ;
 392
 393     //If there's no renderer type specified or if there hasn't been a renderer type change then we can reuse the renderer
 394     if( !type || !type->Get( typeValue ) ||
 395         ( typeValue == IMAGE_RENDERER    && typeid( controlRenderer ) == typeid( ImageRenderer ) ) ||
 396         ( typeValue == N_PATCH_RENDERER  && typeid( controlRenderer ) == typeid( NPatchRenderer ) ) ||
 397         ( typeValue == COLOR_RENDERER    && typeid( controlRenderer ) == typeid( ColorRenderer ) )||
 398         ( typeValue == GRADIENT_RENDERER && typeid( controlRenderer ) == typeid( GradientRenderer ) ) ||
 399         ( typeValue == BORDER_RENDERER   && typeid( controlRenderer ) == typeid( BorderRenderer ) ) ||
 400         ( typeValue == SVG_RENDERER      && typeid( controlRenderer ) == typeid( SvgRenderer ) ) )
 401     {
 402       controlRenderer.Initialize( actor, propertyMap );
 403       return;
 404     }
 405
 406     renderer.RemoveAndReset( actor );
 407   }
 408
 409   renderer = GetControlRenderer( propertyMap );
 410   if( renderer && actor && actor.OnStage() )
 411   {
 412     renderer.SetOnStage( actor );
 413   }
 414 }
 415
 416 Image RendererFactory::GetBrokenRendererImage()
 417 {
 418   return ResourceImage::New( BROKEN_RENDERER_IMAGE_URL );
 419 }
 420
 421 void RendererFactory::CreateAtlasManager()
 422 {
 423   if( !mAtlasManager )
 424   {
 425     Shader shader = ImageRenderer::GetImageShader( *( mFactoryCache.Get() ) );
 426     mAtlasManager = new ImageAtlasManager(shader, TEXTURE_UNIFORM_NAME);
 427     mAtlasManager->SetBrokenImage( BROKEN_RENDERER_IMAGE_URL );
 428   }
 429 }
 430
 431 } // namespace Internal
 432
 433 } // namespace Toolkit
 434
 435 } // namespace Dali
 436