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/color/color-renderer.h>
  29 #include <dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h>
  30 #include <dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.h>
  31 #include <dali-toolkit/internal/controls/renderers/image/image-renderer.h>
  32 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
  33
  34 namespace
  35 {
  36 const char * const RENDERER_TYPE_NAME( "renderer-type" );
  37 const char * const COLOR_RENDERER("color-renderer");
  38 const char * const GRADIENT_RENDERER("gradient-renderer");
  39 const char * const IMAGE_RENDERER("image-renderer");
  40 const char * const N_PATCH_RENDERER("n-patch-renderer");
  41 }
  42
  43 namespace Dali
  44 {
  45
  46 namespace Toolkit
  47 {
  48
  49 namespace Internal
  50 {
  51
  52 namespace
  53 {
  54
  55 BaseHandle Create()
  56 {
  57   BaseHandle handle = Toolkit::RendererFactory::Get();
  58
  59   return handle;
  60 }
  61
  62 DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::RendererFactory, Dali::BaseHandle, Create, true )
  63 DALI_TYPE_REGISTRATION_END()
  64
  65 } // namespace
  66
  67 RendererFactory::RendererFactory()
  68 {
  69 }
  70
  71 RendererFactory::~RendererFactory()
  72 {
  73 }
  74
  75 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Property::Map& propertyMap )
  76 {
  77   ControlRenderer* rendererPtr = NULL;
  78
  79   Property::Value* type = propertyMap.Find( RENDERER_TYPE_NAME );
  80   std::string typeValue ;
  81   if( type && type->Get( typeValue ))
  82   {
  83     if( typeValue ==  COLOR_RENDERER )
  84     {
  85       rendererPtr = new ColorRenderer();
  86     }
  87     else if( typeValue ==  GRADIENT_RENDERER )
  88     {
  89       rendererPtr = new GradientRenderer();
  90     }
  91     else if( typeValue ==  IMAGE_RENDERER )
  92     {
  93       rendererPtr = new ImageRenderer();
  94     }
  95     else if( typeValue ==  N_PATCH_RENDERER )
  96     {
  97       rendererPtr = new NPatchRenderer();
  98     }
  99   }
 100
 101   if( rendererPtr )
 102   {
 103     if( !mFactoryCache )
 104     {
 105       mFactoryCache = new RendererFactoryCache();
 106     }
 107     rendererPtr->Initialize( *( mFactoryCache.Get() ), propertyMap );
 108   }
 109   else
 110   {
 111     DALI_LOG_ERROR( "Renderer type unknown" );
 112   }
 113
 114   return Toolkit::ControlRenderer( rendererPtr );
 115 }
 116
 117 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
 118 {
 119   ColorRenderer* rendererPtr = new ColorRenderer();
 120
 121   if( !mFactoryCache )
 122   {
 123     mFactoryCache = new RendererFactoryCache();
 124   }
 125   rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 126
 127   rendererPtr->SetColor( color );
 128
 129   return Toolkit::ControlRenderer( rendererPtr );
 130 }
 131
 132 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const Vector4& color )
 133 {
 134   ColorRenderer* rendererPtr = dynamic_cast< ColorRenderer* >( &GetImplementation( renderer ) );
 135   if( rendererPtr )
 136   {
 137     rendererPtr->SetColor( color );
 138     return false;
 139   }
 140   else
 141   {
 142     renderer = GetControlRenderer( color );
 143     return true;
 144   }
 145 }
 146
 147 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Image& image )
 148 {
 149   if( !mFactoryCache )
 150   {
 151     mFactoryCache = new RendererFactoryCache();
 152   }
 153
 154   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 155   if( npatchImage )
 156   {
 157     NPatchRenderer* rendererPtr = new NPatchRenderer();
 158     rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 159     rendererPtr->SetImage( npatchImage );
 160
 161     return Toolkit::ControlRenderer( rendererPtr );
 162   }
 163   else
 164   {
 165     ImageRenderer* rendererPtr = new ImageRenderer();
 166     rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 167     rendererPtr->SetImage( image );
 168
 169     return Toolkit::ControlRenderer( rendererPtr );
 170   }
 171 }
 172
 173 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const Image& image )
 174 {
 175   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 176   if( npatchImage )
 177   {
 178     NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 179     if( rendererPtr )
 180     {
 181       rendererPtr->SetImage( npatchImage );
 182       return false;
 183     }
 184   }
 185   else
 186   {
 187     ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 188     if( rendererPtr )
 189     {
 190       rendererPtr->SetImage( image );
 191       return false;
 192     }
 193   }
 194
 195   renderer = GetControlRenderer( image );
 196   return true;
 197 }
 198
 199 Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const std::string& url )
 200 {
 201   if( NinePatchImage::IsNinePatchUrl( url ) )
 202   {
 203     NPatchRenderer* rendererPtr = new NPatchRenderer();
 204     if( !mFactoryCache )
 205     {
 206       mFactoryCache = new RendererFactoryCache();
 207     }
 208     rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 209     rendererPtr->SetImage( url );
 210
 211     return Toolkit::ControlRenderer( rendererPtr );
 212   }
 213   else
 214   {
 215     ImageRenderer* rendererPtr = new ImageRenderer();
 216     if( !mFactoryCache )
 217     {
 218       mFactoryCache = new RendererFactoryCache();
 219     }
 220     rendererPtr->Initialize( *( mFactoryCache.Get() ) );
 221     rendererPtr->SetImage( url );
 222
 223     return Toolkit::ControlRenderer( rendererPtr );
 224   }
 225 }
 226
 227 bool RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, const std::string& url )
 228 {
 229   if( NinePatchImage::IsNinePatchUrl( url ) )
 230   {
 231     NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
 232     if( rendererPtr )
 233     {
 234       rendererPtr->SetImage( url );
 235       return false;
 236     }
 237   }
 238   else
 239   {
 240     ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
 241     if( rendererPtr )
 242     {
 243       rendererPtr->SetImage( url );
 244       return false;
 245     }
 246   }
 247
 248   {
 249     renderer = GetControlRenderer( url );
 250     return true;
 251   }
 252 }
 253
 254 } // namespace Internal
 255
 256 } // namespace Toolkit
 257
 258 } // namespace Dali
 259