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( "renderer-type" );
  38
  39 const char * const COLOR_RENDERER("color-renderer");
  40 const char * const BORDER_RENDERER("border-renderer");
  41 const char * const GRADIENT_RENDERER("gradient-renderer");
  42 const char * const IMAGE_RENDERER("image-renderer");
  43 const char * const N_PATCH_RENDERER("n-patch-renderer");
  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     rendererPtr->Initialize( propertyMap );
 118   }
 119   else
 120   {
 121     DALI_LOG_ERROR( "Renderer type unknown" );
 122   }
 123
 124   return Toolkit::ControlRenderer( rendererPtr );
 125 }
 126
 127 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
 128 {
 129   if( !mFactoryCache )
 130   {
 131     mFactoryCache = new RendererFactoryCache();
 132   }
 133
 134   ColorRenderer* rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );
 135   rendererPtr->SetColor( color );
 136
 137   return Toolkit::ControlRenderer( rendererPtr );
 138 }
 139
 140 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const Vector4& color )
 141 {
 142   ColorRenderer* rendererPtr = dynamic_cast< ColorRenderer* >( &GetImplementation( renderer ) );
 143   if( rendererPtr )
 144   {
 145     rendererPtr->SetColor( color );
 146     return false;
 147   }
 148   else
 149   {
 150     renderer = GetControlRenderer( color );
 151     return true;
 152   }
 153 }
 154
 155 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( float borderSize, const Vector4& borderColor )
 156 {
 157   if( !mFactoryCache )
 158   {
 159     mFactoryCache = new RendererFactoryCache();
 160   }
 161   BorderRenderer* rendererPtr = new BorderRenderer( *mFactoryCache.Get() );
 162
 163   if( !mFactoryCache )
 164   {
 165     mFactoryCache = new RendererFactoryCache();
 166   }
 167
 168   rendererPtr->SetBorderSize( borderSize );
 169   rendererPtr->SetBorderColor( borderColor );
 170
 171   return Toolkit::ControlRenderer( rendererPtr );
 172 }
 173
 174 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Image& image )
 175 {
 176   if( !mFactoryCache )
 177   {
 178     mFactoryCache = new RendererFactoryCache();
 179   }
 180
 181   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 182   if( npatchImage )
 183   {
 184     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 185     rendererPtr->SetImage( npatchImage );
 186
 187     return Toolkit::ControlRenderer( rendererPtr );
 188   }
 189   else
 190   {
 191     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ) );
 192     rendererPtr->SetImage( image );
 193
 194     return Toolkit::ControlRenderer( rendererPtr );
 195   }
 196 }
 197
 198 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const Image& image )
 199 {
 200   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 201   if( npatchImage )
 202   {
 203     NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 204     if( rendererPtr )
 205     {
 206       rendererPtr->SetImage( npatchImage );
 207       return false;
 208     }
 209   }
 210   else
 211   {
 212     ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 213     if( rendererPtr )
 214     {
 215       rendererPtr->SetImage( image );
 216       return false;
 217     }
 218   }
 219
 220   renderer = GetControlRenderer( image );
 221   return true;
 222 }
 223
 224 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const std::string& url )
 225 {
 226   if( !mFactoryCache )
 227   {
 228     mFactoryCache = new RendererFactoryCache();
 229   }
 230
 231   if( NinePatchImage::IsNinePatchUrl( url ) )
 232   {
 233     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 234     rendererPtr->SetImage( url );
 235
 236     return Toolkit::ControlRenderer( rendererPtr );
 237   }
 238   else
 239   {
 240     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ) );
 241     rendererPtr->SetImage( url );
 242
 243     return Toolkit::ControlRenderer( rendererPtr );
 244   }
 245 }
 246
 247 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const std::string& url )
 248 {
 249   if( NinePatchImage::IsNinePatchUrl( url ) )
 250   {
 251     NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 252     if( rendererPtr )
 253     {
 254       rendererPtr->SetImage( url );
 255       return false;
 256     }
 257   }
 258   else
 259   {
 260     ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 261     if( rendererPtr )
 262     {
 263       rendererPtr->SetImage( url );
 264       return false;
 265     }
 266   }
 267
 268   {
 269     renderer = GetControlRenderer( url );
 270     return true;
 271   }
 272 }
 273
 274 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const Property::Map& propertyMap )
 275 {
 276   Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
 277   std::string typeValue ;
 278   if( type && type->Get( typeValue ))
 279   {
 280     //If there's been a renderer type change then we have to return a new shader
 281     if( typeValue ==  COLOR_RENDERER && typeid( renderer ) != typeid( ColorRenderer ) )
 282     {
 283       renderer = GetControlRenderer( propertyMap );
 284       return true;
 285     }
 286     else if( typeValue ==  GRADIENT_RENDERER && typeid( renderer ) != typeid( GradientRenderer ) )
 287     {
 288       renderer = GetControlRenderer( propertyMap );
 289       return true;
 290     }
 291     else if( typeValue ==  IMAGE_RENDERER && typeid( renderer ) != typeid( ImageRenderer ) )
 292     {
 293       renderer = GetControlRenderer( propertyMap );
 294       return true;
 295     }
 296     else if( typeValue ==  N_PATCH_RENDERER && typeid( renderer ) != typeid( NPatchRenderer ) )
 297     {
 298       renderer = GetControlRenderer( propertyMap );
 299       return true;
 300     }
 301     else if( typeValue ==  BORDER_RENDERER && typeid( renderer ) != typeid( BorderRenderer ) )
 302     {
 303       renderer = GetControlRenderer( propertyMap );
 304       return true;
 305     }
 306   }
 307
 308   GetImplementation( renderer ).Initialize( propertyMap );
 309   return false;
 310 }
 311
 312 Image RendererFactory::GetBrokenRendererImage()
 313 {
 314   return ResourceImage::New( BROKEN_RENDERER_IMAGE_URL );
 315 }
 316
 317 } // namespace Internal
 318
 319 } // namespace Toolkit
 320
 321 } // namespace Dali
 322