Merge "Added New methods to cater for second step initialization" into devel/master
[platform/core/uifw/dali-toolkit.git] / 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/batch-image-visual.h>
36 #include <dali-toolkit/internal/visuals/image/image-visual.h>
37 #include <dali-toolkit/internal/visuals/mesh/mesh-visual.h>
38 #include <dali-toolkit/internal/visuals/npatch/npatch-visual.h>
39 #include <dali-toolkit/internal/visuals/primitive/primitive-visual.h>
40 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
41 #include <dali-toolkit/internal/visuals/text/text-visual.h>
42 #include <dali-toolkit/internal/visuals/wireframe/wireframe-visual.h>
43 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
44 #include <dali-toolkit/internal/visuals/visual-factory-resolve-url.h>
45 #include <dali-toolkit/internal/visuals/visual-string-constants.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 const char * const BATCHING_ENABLED( "batchingEnabled" );
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( WireframeVisual::New( *( mFactoryCache.Get() ) ).Get() );
104   }
105
106   Visual::BasePtr visualPtr;
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 = BorderVisual::New( *( mFactoryCache.Get() ) );
120       break;
121     }
122
123     case Toolkit::Visual::COLOR:
124     {
125       visualPtr = ColorVisual::New( *( mFactoryCache.Get() ) );
126       break;
127     }
128
129     case Toolkit::Visual::GRADIENT:
130     {
131       visualPtr = GradientVisual::New( *( 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         // first resolve url type to know which visual to create
142         UrlType::Type type = ResolveUrlType( imageUrl );
143         if( UrlType::N_PATCH == type )
144         {
145           visualPtr = NPatchVisual::New( *( mFactoryCache.Get() ) );
146         }
147         else if( UrlType::SVG == type )
148         {
149           visualPtr = SvgVisual::New( *( mFactoryCache.Get() ) );
150         }
151         else // Regular image
152         {
153           bool batchingEnabled( false );
154           Property::Value* batchingEnabledValue = propertyMap.Find( Toolkit::ImageVisual::Property::BATCHING_ENABLED, BATCHING_ENABLED );
155           if( batchingEnabledValue  )
156           {
157             batchingEnabledValue->Get( batchingEnabled );
158           }
159
160           if( batchingEnabled )
161           {
162             visualPtr = BatchImageVisual::New( *( mFactoryCache.Get() ) );
163             break;
164           }
165           else
166           {
167             visualPtr = ImageVisual::New( *( mFactoryCache.Get() ) );
168           }
169         }
170       }
171
172       break;
173     }
174
175     case Toolkit::Visual::MESH:
176     {
177       visualPtr = MeshVisual::New( *( mFactoryCache.Get() ) );
178       break;
179     }
180
181     case Toolkit::Visual::PRIMITIVE:
182     {
183       visualPtr = PrimitiveVisual::New( *( mFactoryCache.Get() ) );
184       break;
185     }
186
187     case Toolkit::Visual::WIREFRAME:
188     {
189       visualPtr = WireframeVisual::New( *( mFactoryCache.Get() ) );
190       break;
191     }
192
193     case Toolkit::Visual::TEXT:
194     {
195       visualPtr = TextVisual::New( *( mFactoryCache.Get() ) );
196       break;
197     }
198   }
199
200   if( visualPtr )
201   {
202     Actor actor;
203     visualPtr->Initialize( actor, propertyMap );
204   }
205   else
206   {
207     DALI_LOG_ERROR( "Renderer type unknown\n" );
208   }
209
210   return Toolkit::Visual::Base( visualPtr.Get() );
211 }
212
213 Toolkit::Visual::Base VisualFactory::CreateVisual( const Image& image )
214 {
215   if( !mFactoryCache )
216   {
217     mFactoryCache = new VisualFactoryCache();
218   }
219
220   if( mDebugEnabled )
221   {
222     return Toolkit::Visual::Base( WireframeVisual::New( *( mFactoryCache.Get() ) ).Get() );
223   }
224
225   Visual::BasePtr visualPtr;
226
227   NinePatchImage npatchImage = NinePatchImage::DownCast( image );
228   if( npatchImage )
229   {
230     visualPtr = NPatchVisual::New( *( mFactoryCache.Get() ), npatchImage );
231   }
232   else
233   {
234     visualPtr = ImageVisual::New( *( mFactoryCache.Get() ), image );
235   }
236
237   return Toolkit::Visual::Base( visualPtr.Get() );
238 }
239
240 Toolkit::Visual::Base VisualFactory::CreateVisual( const std::string& url, ImageDimensions size )
241 {
242   if( !mFactoryCache )
243   {
244     mFactoryCache = new VisualFactoryCache();
245   }
246
247   if( mDebugEnabled )
248   {
249     return Toolkit::Visual::Base( WireframeVisual::New( *( mFactoryCache.Get() ) ).Get() );
250   }
251
252   Visual::BasePtr visualPtr;
253
254   // first resolve url type to know which visual to create
255   UrlType::Type type = ResolveUrlType( url );
256   if( UrlType::N_PATCH == type )
257   {
258     visualPtr = NPatchVisual::New( *( mFactoryCache.Get() ), url );
259   }
260   else if( UrlType::SVG == type )
261   {
262     visualPtr = SvgVisual::New( *( mFactoryCache.Get() ), url, size );
263   }
264   else // Regular image
265   {
266     visualPtr = ImageVisual::New( *( mFactoryCache.Get() ), url, size );
267   }
268
269   return Toolkit::Visual::Base( visualPtr.Get() );
270 }
271
272 } // namespace Internal
273
274 } // namespace Toolkit
275
276 } // namespace Dali