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