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