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