Revert "Keep aspect ratio of visual in ImageView"
[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 void ImageView::OnStageConnection( int depth )
211 {
212   if( mImage )
213   {
214     mImage.UploadedSignal().Emit( mImage );
215   }
216
217   Dali::ResourceImage resourceImage = Dali::ResourceImage::DownCast( mImage );
218   if( resourceImage )
219   {
220     resourceImage.LoadingFinishedSignal().Emit( resourceImage );
221   }
222
223   Control::OnStageConnection( depth ); // Enabled visuals will be put on stage
224 }
225
226 Vector3 ImageView::GetNaturalSize()
227 {
228   if( mVisual )
229   {
230     Vector2 rendererNaturalSize;
231     mVisual.GetNaturalSize( rendererNaturalSize );
232
233     Extents padding;
234     padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
235
236     rendererNaturalSize.width += ( padding.start + padding.end );
237     rendererNaturalSize.height += ( padding.top + padding.bottom );
238     return Vector3( rendererNaturalSize );
239   }
240
241   // if no visual then use Control's natural size
242   return Control::GetNaturalSize();
243 }
244
245 float ImageView::GetHeightForWidth( float width )
246 {
247   Extents padding;
248   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
249
250   if( mVisual )
251   {
252     return mVisual.GetHeightForWidth( width ) + padding.top + padding.bottom;
253   }
254   else
255   {
256     return Control::GetHeightForWidth( width ) + padding.top + padding.bottom;
257   }
258 }
259
260 float ImageView::GetWidthForHeight( float height )
261 {
262   Extents padding;
263   padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
264
265   if( mVisual )
266   {
267     return mVisual.GetWidthForHeight( height ) + padding.start + padding.end;
268   }
269   else
270   {
271     return Control::GetWidthForHeight( height ) + padding.start + padding.end;
272   }
273 }
274
275 void ImageView::OnRelayout( const Vector2& size, RelayoutContainer& container )
276 {
277   Control::OnRelayout( size, container );
278
279   if( mVisual )
280   {
281     Extents padding;
282     padding = Self().GetProperty<Extents>( Toolkit::Control::Property::PADDING );
283
284     Property::Map transformMap = Property::Map();
285
286     if( ( padding.start != 0 ) || ( padding.end != 0 ) || ( padding.top != 0 ) || ( padding.bottom != 0 ) )
287     {
288       Dali::LayoutDirection::Type layoutDirection = static_cast<Dali::LayoutDirection::Type>( Self().GetProperty(Dali::Actor::Property::LAYOUT_DIRECTION).Get<int>() );
289
290       if( Dali::LayoutDirection::RIGHT_TO_LEFT == layoutDirection )
291       {
292         std::swap(padding.start, padding.end);
293       }
294
295       transformMap.Add( Toolkit::Visual::Transform::Property::OFFSET, Vector2( padding.start, padding.top ) )
296                   .Add( Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE ) )
297                   .Add( Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN )
298                   .Add( Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN );
299     }
300
301     // Should provide a transform that handles aspect ratio according to image size
302     mVisual.SetTransformAndSize( transformMap, size );
303   }
304 }
305
306 void ImageView::OnResourceReady( Toolkit::Control control )
307 {
308   // Visual ready so update visual attached to this ImageView, following call to RelayoutRequest will use this visual.
309   mVisual = DevelControl::GetVisual( *this, Toolkit::ImageView::Property::IMAGE );
310 }
311
312 ///////////////////////////////////////////////////////////
313 //
314 // Properties
315 //
316
317 void ImageView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
318 {
319   Toolkit::ImageView imageView = Toolkit::ImageView::DownCast( Dali::BaseHandle( object ) );
320
321   if ( imageView )
322   {
323     ImageView& impl = GetImpl( imageView );
324     switch ( index )
325     {
326       case Toolkit::ImageView::Property::RESOURCE_URL:
327       {
328         std::string imageUrl;
329         if( value.Get( imageUrl ) )
330         {
331           impl.SetImage( imageUrl, ImageDimensions() );
332         }
333         break;
334       }
335
336       case Toolkit::ImageView::Property::IMAGE:
337       {
338         std::string imageUrl;
339         Property::Map* map;
340         if( value.Get( imageUrl ) )
341         {
342           impl.SetImage( imageUrl, ImageDimensions() );
343         }
344         // if its not a string then get a Property::Map from the property if possible.
345         else
346         {
347           map = value.GetMap();
348           if( map )
349           {
350             Property::Value* shaderValue = map->Find( Toolkit::Visual::Property::SHADER, CUSTOM_SHADER );
351             // set image only if property map contains image information other than custom shader
352             if( map->Count() > 1u ||  !shaderValue )
353             {
354               impl.SetImage( *map );
355             }
356             // the property map contains only the custom shader
357             else if( ( impl.mVisual )&&( map->Count() == 1u )&&( shaderValue ) )
358             {
359               Property::Map* shaderMap = shaderValue->GetMap();
360               if( shaderMap )
361               {
362                 Internal::Visual::Base& visual = Toolkit::GetImplementation( impl.mVisual );
363                 visual.SetCustomShader( *shaderMap );
364                 if( imageView.OnStage() )
365                 {
366                   // force to create new core renderer to use the newly set shader
367                   visual.SetOffStage( imageView );
368                   visual.SetOnStage( imageView );
369                 }
370               }
371             }
372           }
373         }
374         break;
375       }
376
377       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
378       {
379         bool isPre;
380         if( value.Get( isPre ) )
381         {
382           impl.EnablePreMultipliedAlpha( isPre );
383         }
384         break;
385       }
386     }
387   }
388 }
389
390 Property::Value ImageView::GetProperty( BaseObject* object, Property::Index propertyIndex )
391 {
392   Property::Value value;
393
394   Toolkit::ImageView imageview = Toolkit::ImageView::DownCast( Dali::BaseHandle( object ) );
395
396   if ( imageview )
397   {
398     ImageView& impl = GetImpl( imageview );
399     switch ( propertyIndex )
400     {
401       case Toolkit::ImageView::Property::RESOURCE_URL:
402       {
403         if ( !impl.mUrl.empty() )
404         {
405           value = impl.mUrl;
406         }
407         break;
408       }
409
410       case Toolkit::ImageView::Property::IMAGE:
411       {
412         if ( !impl.mUrl.empty() )
413         {
414           value = impl.mUrl;
415         }
416         else if( impl.mImage )
417         {
418           Property::Map map;
419           Scripting::CreatePropertyMap( impl.mImage, map );
420           value = map;
421         }
422         else if( !impl.mPropertyMap.Empty() )
423         {
424           value = impl.mPropertyMap;
425         }
426         break;
427       }
428
429       case Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA:
430       {
431         value = impl.IsPreMultipliedAlphaEnabled();
432         break;
433       }
434     }
435   }
436
437   return value;
438 }
439
440 } // namespace Internal
441 } // namespace Toolkit
442 } // namespace Dali