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/gradient/gradient-visual.h>
  35 #include <dali-toolkit/internal/visuals/image/image-visual.h>
  36 #include <dali-toolkit/internal/visuals/mesh/mesh-visual.h>
  37 #include <dali-toolkit/internal/visuals/npatch/npatch-visual.h>
  38 #include <dali-toolkit/internal/visuals/primitive/primitive-visual.h>
  39 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
  40 #include <dali-toolkit/internal/visuals/wireframe/wireframe-visual.h>
  41 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  42
  43 #include <dali-toolkit/internal/visuals/visual-url.h>
  44 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  45 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
  46
  47 namespace Dali
  48 {
  49
  50 namespace Toolkit
  51 {
  52
  53 namespace Internal
  54 {
  55
  56 namespace
  57 {
  58
  59 DALI_ENUM_TO_STRING_TABLE_BEGIN( VISUAL_TYPE )
  60 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, BORDER )
  61 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, COLOR )
  62 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, GRADIENT )
  63 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, IMAGE )
  64 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, MESH )
  65 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, PRIMITIVE )
  66 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::Visual, WIREFRAME )
  67 DALI_ENUM_TO_STRING_TABLE_END( VISUAL_TYPE )
  68
  69 const char * const VISUAL_TYPE( "visualType" );
  70
  71 BaseHandle Create()
  72 {
  73   BaseHandle handle = Toolkit::VisualFactory::Get();
  74
  75   return handle;
  76 }
  77
  78 DALI_TYPE_REGISTRATION_BEGIN_CREATE( Toolkit::VisualFactory, Dali::BaseHandle, Create, true )
  79 DALI_TYPE_REGISTRATION_END()
  80
  81 } // namespace
  82
  83 VisualFactory::VisualFactory( bool debugEnabled )
  84 :mDebugEnabled( debugEnabled )
  85 {
  86 }
  87
  88 VisualFactory::~VisualFactory()
  89 {
  90 }
  91
  92 Toolkit::Visual::Base VisualFactory::CreateVisual( const Property::Map& propertyMap )
  93 {
  94   // Create factory cache if it hasn't already been
  95   if( !mFactoryCache )
  96   {
  97     mFactoryCache = new VisualFactoryCache();
  98   }
  99
 100   // Return a new WireframeVisual if we have debug enabled
 101   if( mDebugEnabled )
 102   {
 103     return Toolkit::Visual::Base( new WireframeVisual( *( mFactoryCache.Get() ) ) );
 104   }
 105
 106   Visual::Base* visualPtr = NULL;
 107
 108   Property::Value* typeValue = propertyMap.Find( Toolkit::Visual::Property::TYPE, VISUAL_TYPE );
 109   Toolkit::Visual::Type visualType = Toolkit::Visual::IMAGE; // Default to IMAGE type
 110   if( typeValue )
 111   {
 112     Scripting::GetEnumerationProperty( *typeValue, VISUAL_TYPE_TABLE, VISUAL_TYPE_TABLE_COUNT, visualType );
 113   }
 114
 115   switch( visualType )
 116   {
 117     case Toolkit::Visual::BORDER:
 118     {
 119       visualPtr = new BorderVisual( *( mFactoryCache.Get() ) );
 120       break;
 121     }
 122
 123     case Toolkit::Visual::COLOR:
 124     {
 125       visualPtr = new ColorVisual( *( mFactoryCache.Get() ) );
 126       break;
 127     }
 128
 129     case Toolkit::Visual::GRADIENT:
 130     {
 131       visualPtr = new GradientVisual( *( mFactoryCache.Get() ) );
 132       break;
 133     }
 134
 135     case Toolkit::Visual::IMAGE:
 136     {
 137       Property::Value* imageURLValue = propertyMap.Find( Toolkit::ImageVisual::Property::URL, IMAGE_URL_NAME );
 138       std::string imageUrl;
 139       if( imageURLValue && imageURLValue->Get( imageUrl ) )
 140       {
 141
 142         VisualUrl visualUrl( imageUrl );
 143
 144         switch( visualUrl.GetType() )
 145         {
 146           case VisualUrl::N_PATCH:
 147           {
 148             visualPtr = NPatchVisual::New( *( mFactoryCache.Get() ), visualUrl, propertyMap );
 149             break;
 150           }
 151           case VisualUrl::SVG:
 152           {
 153             visualPtr = SvgVisual::New( *( mFactoryCache.Get() ), visualUrl, propertyMap );
 154             break;
 155           }
 156           case VisualUrl::GIF:
 157           {
 158             visualPtr = AnimatedImageVisual::New( *( mFactoryCache.Get() ), visualUrl, propertyMap );
 159             break;
 160           }
 161           case VisualUrl::REGULAR_IMAGE:
 162           {
 163             visualPtr = ImageVisual::New( *( mFactoryCache.Get() ), visualUrl, propertyMap );
 164             break;
 165           }
 166         }
 167       }
 168       break;
 169     }
 170
 171     case Toolkit::Visual::MESH:
 172     {
 173       visualPtr = new MeshVisual( *( mFactoryCache.Get() ) );
 174       break;
 175     }
 176
 177     case Toolkit::Visual::PRIMITIVE:
 178     {
 179       visualPtr = new PrimitiveVisual( *( mFactoryCache.Get() ) );
 180       break;
 181     }
 182
 183     case Toolkit::Visual::WIREFRAME:
 184     {
 185       visualPtr = new WireframeVisual( *( mFactoryCache.Get() ) );
 186       break;
 187     }
 188   }
 189
 190   if( visualPtr )
 191   {
 192     Actor actor;
 193     visualPtr->Initialize( actor, propertyMap );
 194   }
 195   else
 196   {
 197     DALI_LOG_ERROR( "Renderer type unknown\n" );
 198   }
 199
 200   return Toolkit::Visual::Base( visualPtr );
 201 }
 202
 203 Toolkit::Visual::Base VisualFactory::CreateVisual( const Image& image )
 204 {
 205   if( !mFactoryCache )
 206   {
 207     mFactoryCache = new VisualFactoryCache();
 208   }
 209
 210   if( mDebugEnabled )
 211   {
 212     return Toolkit::Visual::Base( new WireframeVisual( *( mFactoryCache.Get() ) ) );
 213   }
 214
 215   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
 216   if( npatchImage )
 217   {
 218     NPatchVisual* visualPtr = new NPatchVisual( *( mFactoryCache.Get() ) );
 219     visualPtr->SetImage( npatchImage );
 220
 221     return Toolkit::Visual::Base( visualPtr );
 222   }
 223   else
 224   {
 225     ImageVisual* visualPtr = new ImageVisual( *( mFactoryCache.Get() ) );
 226     Actor actor;
 227     visualPtr->SetImage( actor, image );
 228
 229     return Toolkit::Visual::Base( visualPtr );
 230   }
 231 }
 232
 233 Toolkit::Visual::Base VisualFactory::CreateVisual( const std::string& url, ImageDimensions size )
 234 {
 235   if( !mFactoryCache )
 236   {
 237     mFactoryCache = new VisualFactoryCache();
 238   }
 239
 240   Visual::BasePtr visualPtr;
 241
 242   // first resolve url type to know which visual to create
 243   VisualUrl visualUrl( url );
 244   switch( visualUrl.GetType() )
 245   {
 246     case VisualUrl::N_PATCH:
 247     {
 248       visualPtr = NPatchVisual::New( *( mFactoryCache.Get() ), visualUrl );
 249       break;
 250     }
 251     case VisualUrl::SVG:
 252     {
 253       visualPtr = SvgVisual::New( *( mFactoryCache.Get() ), visualUrl );
 254       break;
 255     }
 256     case VisualUrl::GIF:
 257     {
 258       visualPtr = AnimatedImageVisual::New( *( mFactoryCache.Get() ), visualUrl );
 259       break;
 260     }
 261     case VisualUrl::REGULAR_IMAGE:
 262     {
 263       visualPtr = ImageVisual::New( *( mFactoryCache.Get() ), visualUrl, size );
 264       break;
 265     }
 266   }
 267
 268     return Toolkit::Visual::Base( visualPtr );
 269   }
 270 }
 271
 272 } // namespace Internal
 273
 274 } // namespace Toolkit
 275
 276 } // namespace Dali