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 <dali-toolkit/internal/controls/renderers/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/public-api/object/type-registry-helper.h>
  26
  27 // INTERNAL INCLUDES
  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/debug/debug-renderer.h>
  31 #include <dali-toolkit/internal/controls/renderers/gradient/gradient-renderer.h>
  32 #include <dali-toolkit/internal/controls/renderers/npatch/npatch-renderer.h>
  33 #include <dali-toolkit/internal/controls/renderers/image/image-renderer.h>
  34 #include <dali-toolkit/internal/controls/renderers/svg/svg-renderer.h>
  35 #include <dali-toolkit/internal/controls/renderers/mesh/mesh-renderer.h>
  36 #include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
  37 #include <dali-toolkit/internal/controls/renderers/renderer-string-constants.h>
  38 #include <dali-toolkit/internal/controls/renderers/image-atlas-manager.h>
  39
  40 namespace
  41 {
  42 const char * const BROKEN_RENDERER_IMAGE_URL( DALI_IMAGE_DIR "broken.png");
  43 }
  44
  45 namespace Dali
  46 {
  47
  48 namespace Toolkit
  49 {
  50
  51 namespace Internal
  52 {
  53
  54 namespace
  55 {
  56
  57 BaseHandle Create()
  58 {
  59   BaseHandle handle = Toolkit::RendererFactory::Get();
  60
  61   return handle;
  62 }
  63
  64 DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::RendererFactory, Dali::BaseHandle, Create, true )
  65 DALI_TYPE_REGISTRATION_END()
  66
  67 } // namespace
  68
  69 RendererFactory::RendererFactory( bool debugEnabled )
  70 :mDebugEnabled( debugEnabled )
  71 {
  72 }
  73
  74 RendererFactory::~RendererFactory()
  75 {
  76 }
  77
  78 RendererFactory::RendererType RendererFactory::GetRendererType( const Property::Map& propertyMap )
  79 {
  80   RendererType rendererType = UNDEFINED;
  81
  82   Property::Value* type = propertyMap.Find( RENDERER_TYPE );
  83   std::string typeValue ;
  84   if( type && type->Get( typeValue ))
  85   {
  86     if( typeValue == COLOR_RENDERER )
  87     {
  88       rendererType = COLOR;
  89     }
  90     else if( typeValue == BORDER_RENDERER )
  91     {
  92       rendererType = BORDER;
  93     }
  94     else if( typeValue == GRADIENT_RENDERER )
  95     {
  96       rendererType = GRADIENT;
  97     }
  98     else if( typeValue == IMAGE_RENDERER )
  99     {
 100       rendererType = IMAGE;
 101     }
 102     else if( typeValue == MESH_RENDERER )
 103     {
 104       rendererType = MESH;
 105     }
 106   }
 107
 108   // check the url if exist, to decide the renderer type
 109   if( rendererType == IMAGE || rendererType == UNDEFINED )
 110   {
 111     Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
 112     std::string imageUrl;
 113     if( imageURLValue && imageURLValue->Get( imageUrl ))
 114     {
 115       if( NinePatchImage::IsNinePatchUrl( imageUrl ) )
 116       {
 117         rendererType = N_PATCH;
 118       }
 119       else if( SvgRenderer::IsSvgUrl( imageUrl ) )
 120       {
 121         rendererType = SVG;
 122       }
 123       else
 124       {
 125         rendererType = IMAGE;
 126       }
 127     }
 128   }
 129
 130   return rendererType;
 131 }
 132
 133 Toolkit::ControlRenderer RendererFactory::CreateControlRenderer( const Property::Map& propertyMap )
 134 {
 135   ControlRenderer* rendererPtr = NULL;
 136
 137   RendererType type = GetRendererType( propertyMap );
 138   if( type != UNDEFINED)
 139   {
 140     if( !mFactoryCache )
 141     {
 142       mFactoryCache = new RendererFactoryCache();
 143     }
 144
 145     if( mDebugEnabled )
 146     {
 147       return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 148     }
 149   }
 150
 151   switch( type )
 152   {
 153     case COLOR:
 154     {
 155       rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );
 156       break;
 157     }
 158      case GRADIENT:
 159      {
 160        rendererPtr = new GradientRenderer( *( mFactoryCache.Get() ) );
 161        break;
 162      }
 163     case BORDER:
 164     {
 165       rendererPtr = new BorderRenderer( *( mFactoryCache.Get() ) );
 166       break;
 167     }
 168     case IMAGE:
 169     {
 170       CreateAtlasManager();
 171       rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 172       break;
 173     }
 174     case N_PATCH:
 175     {
 176       rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 177       break;
 178     }
 179     case SVG:
 180     {
 181       CreateAtlasManager();
 182       rendererPtr = new SvgRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 183       break;
 184     }
 185     case MESH:
 186     {
 187       rendererPtr = new MeshRenderer( *( mFactoryCache.Get() ) );
 188       break;
 189     }
 190     case UNDEFINED:
 191     default:
 192     {
 193       break;
 194     }
 195   }
 196
 197   if( rendererPtr )
 198   {
 199     Actor actor;
 200     rendererPtr->Initialize( actor, propertyMap );
 201   }
 202   else
 203   {
 204     DALI_LOG_ERROR( "Renderer type unknown" );
 205   }
 206
 207   return Toolkit::ControlRenderer( rendererPtr );
 208 }
 209
 210 Toolkit::ControlRenderer RendererFactory::CreateControlRenderer( const Image& image )
 211 {
 212   if( !mFactoryCache )
 213   {
 214     mFactoryCache = new RendererFactoryCache();
 215   }
 216
 217   if( mDebugEnabled )
 218   {
 219     return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 220   }
 221
 222   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 223   if( npatchImage )
 224   {
 225     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 226     rendererPtr->SetImage( npatchImage );
 227
 228     return Toolkit::ControlRenderer( rendererPtr );
 229   }
 230   else
 231   {
 232     CreateAtlasManager();
 233     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 234     Actor actor;
 235     rendererPtr->SetImage( actor, image );
 236
 237     return Toolkit::ControlRenderer( rendererPtr );
 238   }
 239 }
 240
 241 Toolkit::ControlRenderer RendererFactory::CreateControlRenderer( const std::string& url, ImageDimensions size )
 242 {
 243   if( !mFactoryCache )
 244   {
 245     mFactoryCache = new RendererFactoryCache();
 246   }
 247
 248   if( mDebugEnabled )
 249   {
 250     return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
 251   }
 252
 253   if( NinePatchImage::IsNinePatchUrl( url ) )
 254   {
 255     NPatchRenderer* rendererPtr = new NPatchRenderer( *( mFactoryCache.Get() ) );
 256     rendererPtr->SetImage( url );
 257
 258     return Toolkit::ControlRenderer( rendererPtr );
 259   }
 260   else if( SvgRenderer::IsSvgUrl( url ) )
 261   {
 262     CreateAtlasManager();
 263     SvgRenderer* rendererPtr = new SvgRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 264     rendererPtr->SetImage( url, size );
 265     return Toolkit::ControlRenderer( rendererPtr );
 266   }
 267   else
 268   {
 269     CreateAtlasManager();
 270     ImageRenderer* rendererPtr = new ImageRenderer( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 271     Actor actor;
 272     rendererPtr->SetImage( actor, url, size );
 273
 274     return Toolkit::ControlRenderer( rendererPtr );
 275   }
 276 }
 277
 278 Image RendererFactory::GetBrokenRendererImage()
 279 {
 280   return ResourceImage::New( BROKEN_RENDERER_IMAGE_URL );
 281 }
 282
 283 void RendererFactory::CreateAtlasManager()
 284 {
 285   if( !mAtlasManager )
 286   {
 287     Shader shader = ImageRenderer::GetImageShader( *( mFactoryCache.Get() ) );
 288     mAtlasManager = new ImageAtlasManager();
 289     mAtlasManager->SetBrokenImage( BROKEN_RENDERER_IMAGE_URL );
 290   }
 291 }
 292
 293 } // namespace Internal
 294
 295 } // namespace Toolkit
 296
 297 } // namespace Dali