Merge "Fix ImageView OnRelayout and add a commnet in MARGIN property" into devel...
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / image-view / image-view-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
18 // CLASS HEADER
19 #include "image-view-impl.h"
20
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/images/resource-image.h>
23 #include <dali/public-api/object/type-registry.h>
24 #include <dali/public-api/object/type-registry-helper.h>
25 #include <dali/devel-api/scripting/scripting.h>
26
27 // INTERNAL INCLUDES
28 #include <dali-toolkit/public-api/controls/image-view/image-view.h>
29 #include <dali-toolkit/devel-api/controls/control-devel.h>
30 #include <dali-toolkit/public-api/visuals/visual-properties.h>
31 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
32 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
33 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
34 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
35
36 namespace Dali
37 {
38
39 namespace Toolkit
40 {
41
42 namespace Internal
43 {
44
45 namespace
46 {
47
48 BaseHandle Create()
49 {
50   return Toolkit::ImageView::New();
51 }
52
53 // Setup properties, signals and actions using the type-registry.
54 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::ImageView, Toolkit::Control, Create );
55 DALI_PROPERTY_REGISTRATION( Toolkit, ImageView, "resourceUrl", STRING, RESOURCE_URL )
56 DALI_PROPERTY_REGISTRATION( Toolkit, ImageView, "image", MAP, IMAGE )
57 DALI_PROPERTY_REGISTRATION( Toolkit, ImageView, "preMultipliedAlpha", BOOLEAN, PRE_MULTIPLIED_ALPHA )
58
59 DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT( Toolkit, ImageView, "pixelArea", Vector4(0.f, 0.f, 1.f, 1.f), PIXEL_AREA )
60 DALI_TYPE_REGISTRATION_END()
61
62 } // anonymous namespace
63
64 using namespace Dali;
65
66 ImageView::ImageView()
67 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) )
68 {
69 }
70
71 ImageView::~ImageView()
72 {
73 }
74
75 Toolkit::ImageView ImageView::New()
76 {
77   ImageView* impl = new ImageView();
78
79   Toolkit::ImageView handle = Toolkit::ImageView( *impl );
80
81   // Second-phase init of the implementation
82   // This can only be done after the CustomActor connection has been made...
83   impl->Initialize();
84
85   return handle;
86 }
87
88 /////////////////////////////////////////////////////////////
89
90 void ImageView::OnInitialize()
91 {
92   // ImageView can relayout in the OnImageReady, alternative to a signal would be to have a upcall from the Control to ImageView
93   Dali::Toolkit::Control handle( GetOwner() );
94   handle.ResourceReadySignal().Connect( this, &ImageView::OnResourceReady );
95 }
96
97 void ImageView::SetImage( Image image )
98 {
99   // Don't bother comparing if we had a visual previously, just drop old visual and create new one
100   mImage = image;
101   mUrl.clear();
102   mPropertyMap.Clear();
103
104   Toolkit::Visual::Base visual =  Toolkit::VisualFactory::Get().CreateVisual( image );
105   if( visual )
106   {
107     if( !mVisual )
108     {
109       mVisual = visual;
110     }
111
112     DevelControl::RegisterVisual( *this, Toolkit::ImageView::Property::IMAGE, visual  );
113   }
114   else
115   {
116     // Unregister the exsiting visual
117     DevelControl::UnregisterVisual( *this, Toolkit::ImageView::Property::IMAGE );
118
119     // Trigger a size negotiation request that may be needed when unregistering a visual.
120     RelayoutRequest();
121   }
122 }
123
124 void ImageView::SetImage( const Property::Map& map )
125 {
126   // Comparing a property map is too expensive so just creating a new visual
127   mPropertyMap = map;
128   mUrl.clear();
129   mImage.Reset();
130
131   Toolkit::Visual::Base visual =  Toolkit::VisualFactory::Get().CreateVisual( mPropertyMap );
132   if( visual )
133   {
134     // Don't set mVisual until it is ready and shown. Getters will still use current visual.
135     if( !mVisual )
136     {
137       mVisual = visual;
138     }
139
140     DevelControl::RegisterVisual( *this, Toolkit::ImageView::Property::IMAGE, visual  );
141   }
142   else
143   {
144     // Unregister the exsiting visual
145     DevelControl::UnregisterVisual( *this, Toolkit::ImageView::Property::IMAGE );
146
147     // Trigger a size negotiation request that may be needed when unregistering a visual.
148     RelayoutRequest();
149   }
150 }
151
152 void ImageView::SetImage( const std::string& url, ImageDimensions size )
153 {
154   // Don't bother comparing if we had a visual previously, just drop old visual and create new one
155   mUrl = url;
156   mImage.Reset();
157   mPropertyMap.Clear();
158
159   // Don't set mVisual until it is ready and shown. Getters will still use current visual.
160   Toolkit::Visual::Base visual =  Toolkit::VisualFactory::Get().CreateVisual( url, size );
161   if( visual )
162   {
163     if( !mVisual )
164     {
165       mVisual = visual;
166     }
167
168     DevelControl::RegisterVisual( *this, Toolkit::ImageView::Property::IMAGE, visual );
169   }
170   else
171   {
172     // Unregister the exsiting visual
173     DevelControl::UnregisterVisual( *this, Toolkit::ImageView::Property::IMAGE );
174
175     // Trigger a size negotiation request that may be needed when unregistering a visual.
176     RelayoutRequest();
177   }
178 }
179
180 Image ImageView::GetImage() const
181 {
182   return mImage;
183 }
184
185 void ImageView::EnablePreMultipliedAlpha( bool preMultipled )
186 {
187   if( mVisual )
188   {
189     Toolkit::GetImplementation( mVisual ).EnablePreMultipliedAlpha( preMultipled );
190   }
191 }
192
193 bool ImageView::IsPreMultipliedAlphaEnabled() const
194 {
195   if( mVisual )
196   {
197     return Toolkit::GetImplementation( mVisual ).IsPreMultipliedAlphaEnabled();
198   }
199   return false;
200 }
201
202 void ImageView::SetDepthIndex( int depthIndex )
203 {
204   if( mVisual )
205   {
206     mVisual.SetDepthIndex( depthIndex );
207   }
208 }
209
210 Vector3 ImageView::GetNaturalSize()
211 {
212   if( mVisual )
213   {
214     Vector2 rendererNaturalSize;
215     mVisual.GetNaturalSize( rendererNaturalSize );
216
217     Extents padding;
218     padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
219
220     rendererNaturalSize.width += ( padding.start + padding.end );
221     rendererNaturalSize.height += ( padding.top + padding.bottom );
222     return Vector3( rendererNaturalSize );
223   }
224
225   // if no visual then use Control's natural size
226   return Control::GetNaturalSize();
227 }
228
229 float ImageView::GetHeightForWidth( float width )
230 {
231   Extents padding;
232   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
233
234   if( mVisual )
235   {
236     return mVisual.GetHeightForWidth( width ) + padding.top + padding.bottom;
237   }
238   else
239   {
240     return Control::GetHeightForWidth( width ) + padding.top + padding.bottom;
241   }
242 }
243
244 float ImageView::GetWidthForHeight( float height )
245 {
246   Extents padding;
247   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
248
249   if( mVisual )
250   {
251     return mVisual.GetWidthForHeight( height ) + padding.start + padding.end;
252   }
253   else
254   {
255     return Control::GetWidthForHeight( height ) + padding.start + padding.end;
256   }
257 }
258
259 void ImageView::OnRelayout( const Vector2& size, RelayoutContainer& container )
260 {
261   Control::OnRelayout( size, container );
262
263   if( mVisual )
264   {
265     Extents padding;
266     padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
267
268     Property::Map transformMap = Property::Map();
269
270     if( ( padding.start != 0 ) || ( padding.end != 0 ) || ( padding.top != 0 ) || ( padding.bottom != 0 ) )
271     {
272       transformMap.Add( Toolkit::Visual::Transform::Property::OFFSET, Vector2( padding.start, padding.top ) )
273                   .Add( Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) )
274                   .Add( Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
275                   .Add( Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
276     }
277
278     // Should provide a transform that handles aspect ratio according to image size
279     mVisual.SetTransformAndSize( transformMap, size );
280   }
281 }
282
283 void ImageView::OnResourceReady( Toolkit::Control control )
284 {
285   // Visual ready so update visual attached to this ImageView, following call to RelayoutRequest will use this visual.
286   mVisual = DevelControl::GetVisual( *this, Toolkit::ImageView::Property::IMAGE );
287 }
288
289 ///////////////////////////////////////////////////////////
290 //
291 // Properties
292 //
293
294 void ImageView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
295 {
296   Toolkit::ImageView imageView = Toolkit::ImageView::DownCast( Dali::BaseHandle( object ) );
297
298   if ( imageView )
299   {
300     ImageView& impl = GetImpl( imageView );
301     switch ( index )
302     {
303       case Toolkit::ImageView::Property::RESOURCE_URL:
304       {
305         std::string imageUrl;
306         if( value.Get( imageUrl ) )
307         {
308           impl.SetImage( imageUrl, ImageDimensions() );
309         }
310         break;
311       }
312
313       case Toolkit::ImageView::Property::IMAGE:
314       {
315         std::string imageUrl;
316         Property::Map* map;
317         if( value.Get( imageUrl ) )
318         {
319           impl.SetImage( imageUrl, ImageDimensions() );
320         }
321         // if its not a string then get a Property::Map from the property if possible.
322         else
323         {
324           map = value.GetMap();
325           if( map )
326           {
327             Property::Value* shaderValue = map->Find( Toolkit::Visual::Property::SHADER, CUSTOM_SHADER );
328             // set image only if property map contains image information other than custom shader
329             if( map->Count() > 1u ||  !shaderValue )
330             {
331               impl.SetImage( *map );
332             }
333             // the property map contains only the custom shader
334             else if( ( impl.mVisual )&&( map->Count() == 1u )&&( shaderValue ) )
335             {
336               Property::Map* shaderMap = shaderValue->GetMap();
337               if( shaderMap )
338               {
339                 Internal::Visual::Base& visual = Toolkit::GetImplementation( impl.mVisual );
340                 visual.SetCustomShader( *shaderMap );
341                 if( imageView.OnStage() )
342                 {
343                   // force to create new core renderer to use the newly set shader
344                   visual.SetOffStage( imageView );
345                   visual.SetOnStage( imageView );
346                 }
347               }
348             }
349           }
350         }
351         break;
352       }
353
354       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
355       {
356         bool isPre;
357         if( value.Get( isPre ) )
358         {
359           impl.EnablePreMultipliedAlpha( isPre );
360         }
361         break;
362       }
363     }
364   }
365 }
366
367 Property::Value ImageView::GetProperty( BaseObject* object, Property::Index propertyIndex )
368 {
369   Property::Value value;
370
371   Toolkit::ImageView imageview = Toolkit::ImageView::DownCast( Dali::BaseHandle( object ) );
372
373   if ( imageview )
374   {
375     ImageView& impl = GetImpl( imageview );
376     switch ( propertyIndex )
377     {
378       case Toolkit::ImageView::Property::RESOURCE_URL:
379       {
380         if ( !impl.mUrl.empty() )
381         {
382           value = impl.mUrl;
383         }
384         break;
385       }
386
387       case Toolkit::ImageView::Property::IMAGE:
388       {
389         if ( !impl.mUrl.empty() )
390         {
391           value = impl.mUrl;
392         }
393         else if( impl.mImage )
394         {
395           Property::Map map;
396           Scripting::CreatePropertyMap( impl.mImage, map );
397           value = map;
398         }
399         else if( !impl.mPropertyMap.Empty() )
400         {
401           value = impl.mPropertyMap;
402         }
403         break;
404       }
405
406       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
407       {
408         value = impl.IsPreMultipliedAlphaEnabled();
409         break;
410       }
411     }
412   }
413
414   return value;
415 }
416
417 } // namespace Internal
418 } // namespace Toolkit
419 } // namespace Dali