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