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( typeValue ==  COLOR_RENDERER )
  87     {
  88       rendererPtr = new ColorRenderer();
  89     }
  90     else if( typeValue ==  GRADIENT_RENDERER )
  91     {
  92       rendererPtr = new GradientRenderer();
  93     }
  94     else if( typeValue ==  IMAGE_RENDERER )
  95     {
  96       rendererPtr = new ImageRenderer();
  97     }
  98     else if( typeValue ==  N_PATCH_RENDERER )
  99     {
 100       rendererPtr = new NPatchRenderer();
 101     }
 102     else if( typeValue == BORDER_RENDERER )
 103     {
 104       rendererPtr = new BorderRenderer();
 105     }
 106   }
 107
 108   if( rendererPtr )
 109   {
 110     if( !mFactoryCache )
 111     {
 112       mFactoryCache = new RendererFactoryCache();
 113     }
 114     rendererPtr->Initialize( *( mFactoryCache.Get() ), propertyMap );
 115   }
 116   else
 117   {
 118     DALI_LOG_ERROR( "Renderer type unknown" );
 119   }
 120
 121   return Toolkit::ControlRenderer( rendererPtr );
 122 }
 123
 124 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
 125 {
 126   ColorRenderer* rendererPtr = new ColorRenderer();
 127
 128   if( !mFactoryCache )
 129   {
 130     mFactoryCache = new RendererFactoryCache();
 131   }
 132   rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 133
 134   rendererPtr->SetColor( color );
 135
 136   return Toolkit::ControlRenderer( rendererPtr );
 137 }
 138
 139 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const Vector4& color )
 140 {
 141   ColorRenderer* rendererPtr = dynamic_cast< ColorRenderer* >( &GetImplementation( renderer ) );
 142   if( rendererPtr )
 143   {
 144     rendererPtr->SetColor( color );
 145     return false;
 146   }
 147   else
 148   {
 149     renderer = GetControlRenderer( color );
 150     return true;
 151   }
 152 }
 153
 154 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( float borderSize, const Vector4& borderColor )
 155 {
 156   BorderRenderer* rendererPtr = new BorderRenderer();
 157
 158   if( !mFactoryCache )
 159   {
 160     mFactoryCache = new RendererFactoryCache();
 161   }
 162   rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 163
 164   rendererPtr->SetBorderSize( borderSize );
 165   rendererPtr->SetBorderColor( borderColor );
 166
 167   return Toolkit::ControlRenderer( rendererPtr );
 168 }
 169
 170 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Image& image )
 171 {
 172   if( !mFactoryCache )
 173   {
 174     mFactoryCache = new RendererFactoryCache();
 175   }
 176
 177   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 178   if( npatchImage )
 179   {
 180     NPatchRenderer* rendererPtr = new NPatchRenderer();
 181     rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 182     rendererPtr->SetImage( npatchImage );
 183
 184     return Toolkit::ControlRenderer( rendererPtr );
 185   }
 186   else
 187   {
 188     ImageRenderer* rendererPtr = new ImageRenderer();
 189     rendererPtr->Initialize( *( 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( NinePatchImage::IsNinePatchUrl( url ) )
 225   {
 226     NPatchRenderer* rendererPtr = new NPatchRenderer();
 227     if( !mFactoryCache )
 228     {
 229       mFactoryCache = new RendererFactoryCache();
 230     }
 231     rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 232     rendererPtr->SetImage( url );
 233
 234     return Toolkit::ControlRenderer( rendererPtr );
 235   }
 236   else
 237   {
 238     ImageRenderer* rendererPtr = new ImageRenderer();
 239     if( !mFactoryCache )
 240     {
 241       mFactoryCache = new RendererFactoryCache();
 242     }
 243     rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 244     rendererPtr->SetImage( url );
 245
 246     return Toolkit::ControlRenderer( rendererPtr );
 247   }
 248 }
 249
 250 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const std::string& url )
 251 {
 252   if( NinePatchImage::IsNinePatchUrl( url ) )
 253   {
 254     NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 255     if( rendererPtr )
 256     {
 257       rendererPtr->SetImage( url );
 258       return false;
 259     }
 260   }
 261   else
 262   {
 263     ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 264     if( rendererPtr )
 265     {
 266       rendererPtr->SetImage( url );
 267       return false;
 268     }
 269   }
 270
 271   {
 272     renderer = GetControlRenderer( url );
 273     return true;
 274   }
 275 }
 276
 277 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const Property::Map& propertyMap )
 278 {
 279   Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
 280   std::string typeValue ;
 281   if( type && type->Get( typeValue ))
 282   {
 283     //If there's been a renderer type change then we have to return a new shader
 284     if( typeValue ==  COLOR_RENDERER && typeid( renderer ) != typeid( ColorRenderer ) )
 285     {
 286       renderer = GetControlRenderer( propertyMap );
 287       return true;
 288     }
 289     else if( typeValue ==  GRADIENT_RENDERER && typeid( renderer ) != typeid( GradientRenderer ) )
 290     {
 291       renderer = GetControlRenderer( propertyMap );
 292       return true;
 293     }
 294     else if( typeValue ==  IMAGE_RENDERER && typeid( renderer ) != typeid( ImageRenderer ) )
 295     {
 296       renderer = GetControlRenderer( propertyMap );
 297       return true;
 298     }
 299     else if( typeValue ==  N_PATCH_RENDERER && typeid( renderer ) != typeid( NPatchRenderer ) )
 300     {
 301       renderer = GetControlRenderer( propertyMap );
 302       return true;
 303     }
 304     else if( typeValue ==  BORDER_RENDERER && typeid( renderer ) != typeid( BorderRenderer ) )
 305     {
 306       renderer = GetControlRenderer( propertyMap );
 307       return true;
 308     }
 309   }
 310
 311   if( !mFactoryCache )
 312   {
 313     mFactoryCache = new RendererFactoryCache();
 314   }
 315   GetImplementation( renderer ).Initialize( *( mFactoryCache.Get() ), propertyMap );
 316   return false;
 317 }
 318
 319 } // namespace Internal
 320
 321 } // namespace Toolkit
 322
 323 } // namespace Dali
 324