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("color");
  42 const char * const BORDER_RENDERER("border");
  43 const char * const GRADIENT_RENDERER("gradient");
  44 const char * const IMAGE_RENDERER("image");
  45 const char * const N_PATCH_RENDERER("nPatch");
  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, bool antiAliasing )
 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   rendererPtr->RequireAntiAliasing( antiAliasing );
 200
 201   return Toolkit::ControlRenderer( rendererPtr );
 202 }
 203
 204 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Image& image )
 205 {
 206   if( !mFactoryCache )
 207   {
 208     mFactoryCache = new RendererFactoryCache();
 209   }
 210
 211   if( mDebugEnabled )
 212   {
 213     return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 214   }
 215
 216   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 217   if( npatchImage )
 218   {
 219     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 220     rendererPtr->SetImage( npatchImage );
 221
 222     return Toolkit::ControlRenderer( rendererPtr );
 223   }
 224   else
 225   {
 226     CreateAtlasManager();
 227     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 228     Actor actor;
 229     rendererPtr->SetImage( actor, image );
 230
 231     return Toolkit::ControlRenderer( rendererPtr );
 232   }
 233 }
 234
 235 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Image& image )
 236 {
 237   if( mDebugEnabled && renderer )
 238   {
 239     return;
 240   }
 241
 242   if( renderer )
 243   {
 244     if( ! image )
 245     {
 246       // If the image is empty, then reset the renderer and return
 247       renderer.RemoveAndReset( actor );
 248       return;
 249     }
 250
 251     NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 252     if( npatchImage )
 253     {
 254       NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 255       if( rendererPtr )
 256       {
 257         rendererPtr->SetImage( npatchImage );
 258         return;
 259       }
 260     }
 261     else
 262     {
 263       ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 264       if( rendererPtr )
 265       {
 266         rendererPtr->SetImage( actor, image );
 267         return;
 268       }
 269     }
 270
 271     renderer.RemoveAndReset( actor );
 272   }
 273
 274   renderer = GetControlRenderer( image );
 275   if( actor && actor.OnStage() )
 276   {
 277     renderer.SetOnStage( actor );
 278   }
 279 }
 280
 281 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const std::string& url, ImageDimensions size )
 282 {
 283   if( !mFactoryCache )
 284   {
 285     mFactoryCache = new RendererFactoryCache();
 286   }
 287
 288   if( mDebugEnabled )
 289   {
 290     return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 291   }
 292
 293   if( NinePatchImage::IsNinePatchUrl( url ) )
 294   {
 295     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 296     rendererPtr->SetImage( url );
 297
 298     return Toolkit::ControlRenderer( rendererPtr );
 299   }
 300   else
 301   {
 302     CreateAtlasManager();
 303     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 304     Actor actor;
 305     rendererPtr->SetImage( actor, url, size );
 306
 307     return Toolkit::ControlRenderer( rendererPtr );
 308   }
 309 }
 310
 311 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const std::string& url, ImageDimensions size )
 312 {
 313   if( mDebugEnabled && renderer )
 314   {
 315     return;
 316   }
 317
 318   if( renderer )
 319   {
 320     if( url.empty() )
 321     {
 322       // If the URL is empty, then reset the renderer and return
 323       renderer.RemoveAndReset( actor );
 324       return;
 325     }
 326     else if( NinePatchImage::IsNinePatchUrl( url ) )
 327     {
 328       NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 329       if( rendererPtr )
 330       {
 331         rendererPtr->SetImage( url );
 332         return;
 333       }
 334     }
 335     else
 336     {
 337       ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 338       if( rendererPtr )
 339       {
 340         rendererPtr->SetImage( actor, url, size );
 341         return;
 342       }
 343     }
 344
 345     renderer.RemoveAndReset( actor );
 346   }
 347
 348   renderer = GetControlRenderer( url, size );
 349   if( actor && actor.OnStage() )
 350   {
 351     renderer.SetOnStage( actor );
 352   }
 353 }
 354
 355 void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap )
 356 {
 357   if( mDebugEnabled && renderer )
 358   {
 359     return;
 360   }
 361
 362   if( renderer )
 363   {
 364     ControlRenderer& controlRenderer = GetImplementation( renderer );
 365
 366     Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
 367     std::string typeValue ;
 368
 369     //If there's no renderer type specified or if there hasn't been a renderer type change then we can reuse the renderer
 370     if( !type || !type->Get( typeValue ) ||
 371         ( typeValue ==  IMAGE_RENDERER    && typeid( controlRenderer ) == typeid( ImageRenderer ) ) ||
 372         ( typeValue ==  N_PATCH_RENDERER  && typeid( controlRenderer ) == typeid( NPatchRenderer ) ) ||
 373         ( typeValue ==  COLOR_RENDERER    && typeid( controlRenderer ) == typeid( ColorRenderer ) )||
 374         ( typeValue ==  GRADIENT_RENDERER && typeid( controlRenderer ) == typeid( GradientRenderer ) ) ||
 375         ( typeValue ==  BORDER_RENDERER   && typeid( controlRenderer ) == typeid( BorderRenderer ) ) )
 376     {
 377       controlRenderer.Initialize( actor, propertyMap );
 378       return;
 379     }
 380
 381     renderer.RemoveAndReset( actor );
 382   }
 383
 384   renderer = GetControlRenderer( propertyMap );
 385   if( renderer && actor && actor.OnStage() )
 386   {
 387     renderer.SetOnStage( actor );
 388   }
 389 }
 390
 391 Image RendererFactory::GetBrokenRendererImage()
 392 {
 393   return ResourceImage::New( BROKEN_RENDERER_IMAGE_URL );
 394 }
 395
 396 void RendererFactory::CreateAtlasManager()
 397 {
 398   if( !mAtlasManager )
 399   {
 400     Shader shader = ImageRenderer::GetImageShader( *( mFactoryCache.Get() ) );
 401     mAtlasManager = new ImageAtlasManager(shader, TEXTURE_UNIFORM_NAME);
 402     mAtlasManager->SetBrokenImage( BROKEN_RENDERER_IMAGE_URL );
 403   }
 404 }
 405
 406 } // namespace Internal
 407
 408 } // namespace Toolkit
 409
 410 } // namespace Dali
 411