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

   1  /*
   2  * Copyright (c) 2016 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/enum-helper.h>
  27 #include <dali/devel-api/scripting/scripting.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  31 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  32 #include <dali-toolkit/internal/visuals/border/border-visual.h>
  33 #include <dali-toolkit/internal/visuals/color/color-visual.h>
  34 #include <dali-toolkit/internal/visuals/debug/debug-visual.h>
  35 #include <dali-toolkit/internal/visuals/gradient/gradient-visual.h>
  36 #include <dali-toolkit/internal/visuals/npatch/npatch-visual.h>
  37 #include <dali-toolkit/internal/visuals/image/image-visual.h>
  38 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
  39 #include <dali-toolkit/internal/visuals/mesh/mesh-visual.h>
  40 #include <dali-toolkit/internal/visuals/primitive/primitive-visual.h>
  41 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  42 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  43 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
  44 #include <dali-toolkit/internal/visuals/image/batch-image-visual.h>
  45
  46 namespace
  47 {
  48 const char * const BROKEN_VISUAL_IMAGE_URL( DALI_IMAGE_DIR "broken.png");
  49 }
  50
  51 namespace Dali
  52 {
  53
  54 namespace Toolkit
  55 {
  56
  57 namespace Internal
  58 {
  59
  60 namespace
  61 {
  62
  63 DALI_ENUM_TO_STRING_TABLE_BEGIN( VISUAL_TYPE )
  64 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, BORDER )
  65 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, COLOR )
  66 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, GRADIENT )
  67 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, IMAGE )
  68 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, MESH )
  69 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, PRIMITIVE )
  70 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, DEBUG )
  71 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, BATCH_IMAGE )
  72 DALI_ENUM_TO_STRING_TABLE_END( VISUAL_TYPE )
  73
  74 const char * const VISUAL_TYPE( "visualType" );
  75 const char * const BATCHING_ENABLED( "batchingEnabled" );
  76
  77 BaseHandle Create()
  78 {
  79   BaseHandle handle = Toolkit::VisualFactory::Get();
  80
  81   return handle;
  82 }
  83
  84 DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::VisualFactory, Dali::BaseHandle, Create, true )
  85 DALI_TYPE_REGISTRATION_END()
  86
  87 } // namespace
  88
  89 VisualFactory::VisualFactory( bool debugEnabled )
  90 :mDebugEnabled( debugEnabled )
  91 {
  92 }
  93
  94 VisualFactory::~VisualFactory()
  95 {
  96 }
  97
  98 Toolkit::Visual::Base VisualFactory::CreateVisual( const Property::Map& propertyMap )
  99 {
 100   // Create factory cache if it hasn't already been
 101   if( !mFactoryCache )
 102   {
 103     mFactoryCache = new VisualFactoryCache();
 104   }
 105
 106   // Return a new DebugVisual if we have debug enabled
 107   if( mDebugEnabled )
 108   {
 109     return Toolkit::Visual::Base( new DebugVisual( *( mFactoryCache.Get() ) ) );
 110   }
 111
 112   Visual::Base* visualPtr = NULL;
 113
 114   Property::Value* typeValue = propertyMap.Find( Toolkit::Visual::Property::TYPE, VISUAL_TYPE );
 115   Toolkit::Visual::Type visualType = Toolkit::Visual::IMAGE; // Default to IMAGE type.
 116   if( typeValue )
 117   {
 118     Scripting::GetEnumerationProperty( *typeValue, VISUAL_TYPE_TABLE, VISUAL_TYPE_TABLE_COUNT, visualType );
 119   }
 120
 121   // If the type is IMAGE, either from a default or the TYPE value in the property-map, change it to a BatchImage if required.
 122   if( visualType == Toolkit::Visual::IMAGE )
 123   {
 124     bool batchingEnabled( false );
 125     Property::Value* value = propertyMap.Find( Toolkit::Visual::Property::BATCHING_ENABLED, BATCHING_ENABLED );
 126     if( value )
 127     {
 128       value->Get( batchingEnabled );
 129       if( batchingEnabled )
 130       {
 131         visualType = Toolkit::Visual::BATCH_IMAGE;
 132       }
 133     }
 134   }
 135
 136   switch( visualType )
 137   {
 138     case Toolkit::Visual::BORDER:
 139     {
 140       visualPtr = new BorderVisual( *( mFactoryCache.Get() ) );
 141       break;
 142     }
 143
 144     case Toolkit::Visual::COLOR:
 145     {
 146       visualPtr = new ColorVisual( *( mFactoryCache.Get() ) );
 147       break;
 148     }
 149
 150     case Toolkit::Visual::GRADIENT:
 151     {
 152       visualPtr = new GradientVisual( *( mFactoryCache.Get() ) );
 153       break;
 154     }
 155
 156     default: // Default to Image type if unknown (check if there is a URL)
 157     case Toolkit::Visual::IMAGE:
 158     {
 159       Property::Value* imageURLValue = propertyMap.Find( Toolkit::ImageVisual::Property::URL, IMAGE_URL_NAME );
 160       std::string imageUrl;
 161       if( imageURLValue && imageURLValue->Get( imageUrl ) )
 162       {
 163         if( NinePatchImage::IsNinePatchUrl( imageUrl ) )
 164         {
 165           visualPtr = new NPatchVisual( *( mFactoryCache.Get() ) );
 166         }
 167         else
 168         {
 169           CreateAtlasManager();
 170
 171           if( SvgVisual::IsSvgUrl( imageUrl ) )
 172           {
 173             visualPtr = new SvgVisual( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 174           }
 175           else
 176           {
 177             visualPtr = new ImageVisual( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 178           }
 179         }
 180       }
 181       else if( propertyMap.Find( Toolkit::Visual::Property::SHADER, CUSTOM_SHADER ) )
 182       {
 183         // Create Image Visual if it has a shader
 184         // TODO: This is required because of EffectsView which should be fixed
 185         CreateAtlasManager();
 186         visualPtr = new ImageVisual( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 187       }
 188       break;
 189     }
 190
 191     case Toolkit::Visual::MESH:
 192     {
 193       visualPtr = new MeshVisual( *( mFactoryCache.Get() ) );
 194       break;
 195     }
 196
 197     case Toolkit::Visual::PRIMITIVE:
 198     {
 199       visualPtr = new PrimitiveVisual( *( mFactoryCache.Get() ) );
 200       break;
 201     }
 202
 203     case Toolkit::Visual::DEBUG:
 204     {
 205       visualPtr = new DebugVisual( *( mFactoryCache.Get() ) );
 206       break;
 207     }
 208
 209     case Toolkit::Visual::BATCH_IMAGE:
 210     {
 211       CreateAtlasManager();
 212       visualPtr = new BatchImageVisual( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 213       break;
 214     }
 215   }
 216
 217   if( visualPtr )
 218   {
 219     Actor actor;
 220     visualPtr->Initialize( actor, propertyMap );
 221   }
 222   else
 223   {
 224     DALI_LOG_ERROR( "Renderer type unknown\n" );
 225   }
 226
 227   return Toolkit::Visual::Base( visualPtr );
 228 }
 229
 230 Toolkit::Visual::Base VisualFactory::CreateVisual( const Image& image )
 231 {
 232   if( !mFactoryCache )
 233   {
 234     mFactoryCache = new VisualFactoryCache();
 235   }
 236
 237   if( mDebugEnabled )
 238   {
 239     return Toolkit::Visual::Base( new DebugVisual( *( mFactoryCache.Get() ) ) );
 240   }
 241
 242   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 243   if( npatchImage )
 244   {
 245     NPatchVisual* visualPtr = new NPatchVisual( *( mFactoryCache.Get() ) );
 246     visualPtr->SetImage( npatchImage );
 247
 248     return Toolkit::Visual::Base( visualPtr );
 249   }
 250   else
 251   {
 252     CreateAtlasManager();
 253     ImageVisual* visualPtr = new ImageVisual( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 254     Actor actor;
 255     visualPtr->SetImage( actor, image );
 256
 257     return Toolkit::Visual::Base( visualPtr );
 258   }
 259 }
 260
 261 Toolkit::Visual::Base VisualFactory::CreateVisual( const std::string& url, ImageDimensions size )
 262 {
 263   if( !mFactoryCache )
 264   {
 265     mFactoryCache = new VisualFactoryCache();
 266   }
 267
 268   if( mDebugEnabled )
 269   {
 270     return Toolkit::Visual::Base( new DebugVisual( *( mFactoryCache.Get() ) ) );
 271   }
 272
 273   if( NinePatchImage::IsNinePatchUrl( url ) )
 274   {
 275     NPatchVisual* visualPtr = new NPatchVisual( *( mFactoryCache.Get() ) );
 276     visualPtr->SetImage( url );
 277
 278     return Toolkit::Visual::Base( visualPtr );
 279   }
 280   else if( SvgVisual::IsSvgUrl( url ) )
 281   {
 282     CreateAtlasManager();
 283     SvgVisual* visualPtr = new SvgVisual( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 284     visualPtr->SetImage( url, size );
 285     return Toolkit::Visual::Base( visualPtr );
 286   }
 287   else
 288   {
 289     CreateAtlasManager();
 290     ImageVisual* visualPtr = new ImageVisual( *( mFactoryCache.Get() ), *( mAtlasManager.Get() ) );
 291     Actor actor;
 292     visualPtr->SetImage( actor, url, size );
 293
 294     return Toolkit::Visual::Base( visualPtr );
 295   }
 296 }
 297
 298 Image VisualFactory::GetBrokenVisualImage()
 299 {
 300   return ResourceImage::New( BROKEN_VISUAL_IMAGE_URL );
 301 }
 302
 303 void VisualFactory::CreateAtlasManager()
 304 {
 305   if( !mAtlasManager )
 306   {
 307     Shader shader = ImageVisual::GetImageShader( *( mFactoryCache.Get() ) );
 308     mAtlasManager = new ImageAtlasManager();
 309     mAtlasManager->SetBrokenImage( BROKEN_VISUAL_IMAGE_URL );
 310   }
 311 }
 312
 313 } // namespace Internal
 314
 315 } // namespace Toolkit
 316
 317 } // namespace Dali