dali-toolkit/internal/visuals/visual-factory-impl.cpp

   1  /*
   2  * Copyright (c) 2017 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 #include <dali/devel-api/scripting/scripting.h>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  30 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  31 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
  32 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  33 #include <dali-toolkit/internal/visuals/border/border-visual.h>
  34 #include <dali-toolkit/internal/visuals/color/color-visual.h>
  35 #include <dali-toolkit/internal/visuals/gradient/gradient-visual.h>
  36 #include <dali-toolkit/internal/visuals/animated-gradient/animated-gradient-visual.h>
  37 #include <dali-toolkit/internal/visuals/image/image-visual.h>
  38 #include <dali-toolkit/internal/visuals/mesh/mesh-visual.h>
  39 #include <dali-toolkit/internal/visuals/npatch/npatch-visual.h>
  40 #include <dali-toolkit/internal/visuals/primitive/primitive-visual.h>
  41 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
  42 #include <dali-toolkit/internal/visuals/text/text-visual.h>
  43 #include <dali-toolkit/internal/visuals/animated-image/animated-image-visual.h>
  44 #include <dali-toolkit/internal/visuals/wireframe/wireframe-visual.h>
  45 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  46 #include <dali-toolkit/internal/visuals/visual-url.h>
  47 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  48
  49 namespace Dali
  50 {
  51
  52 namespace Toolkit
  53 {
  54
  55 namespace Internal
  56 {
  57
  58 namespace
  59 {
  60
  61 BaseHandle Create()
  62 {
  63   BaseHandle handle = Toolkit::VisualFactory::Get();
  64
  65   return handle;
  66 }
  67
  68 DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::VisualFactory, Dali::BaseHandle, Create, true )
  69 DALI_TYPE_REGISTRATION_END()
  70
  71 } // namespace
  72
  73 VisualFactory::VisualFactory( bool debugEnabled )
  74 : mDebugEnabled( debugEnabled ),
  75   mPreMultiplyOnLoad( true )
  76 {
  77 }
  78
  79 VisualFactory::~VisualFactory()
  80 {
  81 }
  82
  83 Toolkit::Visual::Base VisualFactory::CreateVisual( const Property::Map& propertyMap )
  84 {
  85   Visual::BasePtr visualPtr;
  86
  87   Property::Value* typeValue = propertyMap.Find( Toolkit::Visual::Property::TYPE, VISUAL_TYPE );
  88   Toolkit::DevelVisual::Type visualType = Toolkit::DevelVisual::IMAGE; // Default to IMAGE type.
  89   if( typeValue )
  90   {
  91     Scripting::GetEnumerationProperty( *typeValue, VISUAL_TYPE_TABLE, VISUAL_TYPE_TABLE_COUNT, visualType );
  92   }
  93
  94   switch( visualType )
  95   {
  96     case Toolkit::Visual::BORDER:
  97     {
  98       visualPtr = BorderVisual::New( GetFactoryCache(), propertyMap );
  99       break;
 100     }
 101
 102     case Toolkit::Visual::COLOR:
 103     {
 104       visualPtr = ColorVisual::New( GetFactoryCache(), propertyMap );
 105       break;
 106     }
 107
 108     case Toolkit::Visual::GRADIENT:
 109     {
 110       visualPtr = GradientVisual::New( GetFactoryCache(), propertyMap );
 111       break;
 112     }
 113
 114     case Toolkit::Visual::IMAGE:
 115     {
 116       Property::Value* imageURLValue = propertyMap.Find( Toolkit::ImageVisual::Property::URL, IMAGE_URL_NAME );
 117       std::string imageUrl;
 118       if( imageURLValue )
 119       {
 120         if( imageURLValue->Get( imageUrl ) )
 121         {
 122           if( !imageUrl.empty() )
 123           {
 124             VisualUrl visualUrl( imageUrl );
 125
 126             switch( visualUrl.GetType() )
 127             {
 128               case VisualUrl::N_PATCH:
 129               {
 130                 visualPtr = NPatchVisual::New( GetFactoryCache(), visualUrl, propertyMap );
 131                 break;
 132               }
 133               case VisualUrl::SVG:
 134               {
 135                 visualPtr = SvgVisual::New( GetFactoryCache(), visualUrl, propertyMap );
 136                 break;
 137               }
 138               case VisualUrl::GIF:
 139               {
 140                 visualPtr = AnimatedImageVisual::New( GetFactoryCache(), visualUrl, propertyMap );
 141                 break;
 142               }
 143               case VisualUrl::REGULAR_IMAGE:
 144               {
 145                 visualPtr = ImageVisual::New( GetFactoryCache(), visualUrl, propertyMap );
 146                 break;
 147               }
 148             }
 149           }
 150         }
 151         else
 152         {
 153           Property::Array* array = imageURLValue->GetArray();
 154           if( array )
 155           {
 156             visualPtr = AnimatedImageVisual::New( GetFactoryCache(), *array, propertyMap );
 157           }
 158         }
 159       }
 160       break;
 161     }
 162
 163     case Toolkit::Visual::MESH:
 164     {
 165       visualPtr = MeshVisual::New( GetFactoryCache(), propertyMap );
 166       break;
 167     }
 168
 169     case Toolkit::Visual::PRIMITIVE:
 170     {
 171       visualPtr = PrimitiveVisual::New( GetFactoryCache(), propertyMap );
 172       break;
 173     }
 174
 175     case Toolkit::Visual::WIREFRAME:
 176     {
 177       visualPtr = WireframeVisual::New( GetFactoryCache(), propertyMap );
 178       break;
 179     }
 180
 181     case Toolkit::Visual::TEXT:
 182     {
 183       visualPtr = TextVisual::New( GetFactoryCache(), propertyMap );
 184       break;
 185     }
 186
 187     case Toolkit::Visual::N_PATCH:
 188     {
 189       Property::Value* imageURLValue = propertyMap.Find( Toolkit::ImageVisual::Property::URL, IMAGE_URL_NAME );
 190       std::string imageUrl;
 191       if( imageURLValue && imageURLValue->Get( imageUrl ) )
 192       {
 193         visualPtr = NPatchVisual::New( GetFactoryCache(), imageUrl, propertyMap );
 194       }
 195       break;
 196     }
 197
 198     case Toolkit::Visual::SVG:
 199     {
 200       Property::Value* imageURLValue = propertyMap.Find( Toolkit::ImageVisual::Property::URL, IMAGE_URL_NAME );
 201       std::string imageUrl;
 202       if( imageURLValue && imageURLValue->Get( imageUrl ) )
 203       {
 204         visualPtr = SvgVisual::New( GetFactoryCache(), imageUrl, propertyMap );
 205       }
 206       break;
 207     }
 208
 209     case Toolkit::Visual::ANIMATED_IMAGE:
 210     {
 211       Property::Value* imageURLValue = propertyMap.Find( Toolkit::ImageVisual::Property::URL, IMAGE_URL_NAME );
 212       std::string imageUrl;
 213       if( imageURLValue )
 214       {
 215         if( imageURLValue->Get( imageUrl ) )
 216         {
 217           visualPtr = AnimatedImageVisual::New( GetFactoryCache(), imageUrl, propertyMap );
 218         }
 219         else
 220         {
 221           Property::Array* array = imageURLValue->GetArray();
 222           if( array )
 223           {
 224             visualPtr = AnimatedImageVisual::New( GetFactoryCache(), *array, propertyMap );
 225           }
 226         }
 227       }
 228       break;
 229     }
 230
 231     case Toolkit::DevelVisual::ANIMATED_GRADIENT:
 232     {
 233       visualPtr = AnimatedGradientVisual::New( GetFactoryCache(), propertyMap );
 234       break;
 235     }
 236   }
 237
 238   if( !visualPtr )
 239   {
 240     DALI_LOG_ERROR( "Renderer type unknown\n" );
 241   }
 242
 243   if( mDebugEnabled && visualType !=  Toolkit::DevelVisual::WIREFRAME )
 244   {
 245     //Create a WireframeVisual if we have debug enabled
 246     visualPtr = WireframeVisual::New(GetFactoryCache(), visualPtr, propertyMap );
 247   }
 248
 249   return Toolkit::Visual::Base( visualPtr.Get() );
 250 }
 251
 252 Toolkit::Visual::Base VisualFactory::CreateVisual( const Image& image )
 253 {
 254   Visual::BasePtr visualPtr;
 255
 256   if( image )
 257   {
 258     NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 259     if( npatchImage )
 260     {
 261       visualPtr = NPatchVisual::New( GetFactoryCache(), npatchImage );
 262     }
 263     else
 264     {
 265       visualPtr = ImageVisual::New(GetFactoryCache(), image );
 266     }
 267   }
 268
 269   if( mDebugEnabled )
 270   {
 271     //Create a WireframeVisual if we have debug enabled
 272     visualPtr = WireframeVisual::New( GetFactoryCache(), visualPtr );
 273   }
 274
 275   return Toolkit::Visual::Base( visualPtr.Get() );
 276 }
 277
 278 Toolkit::Visual::Base VisualFactory::CreateVisual( const std::string& url, ImageDimensions size )
 279 {
 280   Visual::BasePtr visualPtr;
 281
 282   if( !url.empty() )
 283   {
 284     // first resolve url type to know which visual to create
 285     VisualUrl visualUrl( url );
 286     switch( visualUrl.GetType() )
 287     {
 288       case VisualUrl::N_PATCH:
 289       {
 290         visualPtr = NPatchVisual::New( GetFactoryCache(), visualUrl );
 291         break;
 292       }
 293       case VisualUrl::SVG:
 294       {
 295         visualPtr = SvgVisual::New( GetFactoryCache(), visualUrl );
 296         break;
 297       }
 298       case VisualUrl::GIF:
 299       {
 300         visualPtr = AnimatedImageVisual::New( GetFactoryCache(), visualUrl );
 301         break;
 302       }
 303       case VisualUrl::REGULAR_IMAGE:
 304       {
 305         visualPtr = ImageVisual::New(GetFactoryCache(), visualUrl, size );
 306         break;
 307       }
 308     }
 309   }
 310
 311   if( mDebugEnabled )
 312   {
 313     //Create a WireframeVisual if we have debug enabled
 314     visualPtr = WireframeVisual::New( GetFactoryCache(), visualPtr );
 315   }
 316
 317   return Toolkit::Visual::Base( visualPtr.Get() );
 318 }
 319
 320 void VisualFactory::SetPreMultiplyOnLoad( bool preMultiply )
 321 {
 322   if( mPreMultiplyOnLoad != preMultiply )
 323   {
 324     GetFactoryCache().SetPreMultiplyOnLoad( preMultiply );
 325   }
 326   mPreMultiplyOnLoad = preMultiply;
 327 }
 328
 329 bool VisualFactory::GetPreMultiplyOnLoad() const
 330 {
 331   return mPreMultiplyOnLoad;
 332 }
 333
 334 Internal::TextureManager& VisualFactory::GetTextureManager()
 335 {
 336   return GetFactoryCache().GetTextureManager();
 337 }
 338
 339 Internal::VisualFactoryCache& VisualFactory::GetFactoryCache()
 340 {
 341   if( !mFactoryCache )
 342   {
 343     mFactoryCache = std::unique_ptr<VisualFactoryCache>( new VisualFactoryCache( mPreMultiplyOnLoad ) );
 344   }
 345   return *mFactoryCache;
 346 }
 347
 348 } // namespace Internal
 349
 350 } // namespace Toolkit
 351
 352 } // namespace Dali