Merge "Do not reposition the text's popup when buttons are pressed." into devel/master
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / magnifier / magnifier-impl.cpp
1 /*
2  * Copyright (c) 2014 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 <dali-toolkit/internal/controls/magnifier/magnifier-impl.h>
20
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/animation/constraint.h>
23 #include <dali/public-api/animation/constraints.h>
24 #include <dali/public-api/common/stage.h>
25 #include <dali/public-api/render-tasks/render-task-list.h>
26 #include <dali/public-api/images/resource-image.h>
27 #include <dali/public-api/object/type-registry.h>
28 #include <dali/devel-api/object/type-registry-helper.h>
29
30 // INTERNAL INCLUDES
31 #include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
32
33 namespace Dali
34 {
35
36 namespace Toolkit
37 {
38
39 namespace Internal
40 {
41
42 namespace // unnamed namespace
43 {
44
45
46 Dali::BaseHandle Create()
47 {
48   return Toolkit::Magnifier::New();
49 }
50
51 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Magnifier, Toolkit::Control, Create )
52
53 DALI_PROPERTY_REGISTRATION( Toolkit, Magnifier, "frame-visibility",     BOOLEAN, FRAME_VISIBILITY     )
54 DALI_PROPERTY_REGISTRATION( Toolkit, Magnifier, "magnification-factor", FLOAT,   MAGNIFICATION_FACTOR )
55
56 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Magnifier, "source-position", VECTOR3, SOURCE_POSITION )
57
58 DALI_TYPE_REGISTRATION_END()
59
60 const float IMAGE_BORDER_INDENT = 5.0f;            ///< Indent of border in pixels.
61
62 struct CameraActorPositionConstraint
63 {
64   CameraActorPositionConstraint(const Vector2& stageSize, float defaultCameraDistance = 0.0f)
65   : mStageSize(stageSize),
66     mDefaultCameraDistance(defaultCameraDistance)
67   {
68   }
69
70   void operator()( Vector3& current, const PropertyInputContainer& inputs )
71   {
72     const Vector3& sourcePosition = inputs[0]->GetVector3();
73
74     current.x = sourcePosition.x + mStageSize.x * 0.5f;
75     current.y = sourcePosition.y + mStageSize.y * 0.5f;
76     current.z = sourcePosition.z + mDefaultCameraDistance;
77   }
78
79   Vector2 mStageSize;
80   float mDefaultCameraDistance;
81
82 };
83
84 struct RenderTaskViewportPositionConstraint
85 {
86   RenderTaskViewportPositionConstraint(const Vector2& stageSize)
87   : mStageSize(stageSize)
88   {
89   }
90
91   void operator()( Vector2& current, const PropertyInputContainer& inputs )
92   {
93     current = inputs[0]->GetVector3(); // World position?
94
95     // should be updated when:
96     // Magnifier's world position/size/scale/parentorigin/anchorpoint changes.
97     // or Magnifier camera's world position changes.
98     Vector3 size = inputs[1]->GetVector3() * inputs[2]->GetVector3(); /* magnifier-size * magnifier-scale */
99
100     // Reposition, and resize viewport to reflect the world bounds of this Magnifier actor.
101     current.x += ( mStageSize.width - size.width ) * 0.5f;
102     current.y += ( mStageSize.height - size.height ) * 0.5f;
103   }
104
105   Vector2 mStageSize;
106 };
107
108 struct RenderTaskViewportSizeConstraint
109 {
110   RenderTaskViewportSizeConstraint()
111   {
112   }
113
114   void operator()( Vector2& current, const PropertyInputContainer& inputs )
115   {
116     current = inputs[0]->GetVector3() * inputs[1]->GetVector3(); /* magnifier-size * magnifier-scale */
117   }
118 };
119
120 } // unnamed namespace
121
122 ///////////////////////////////////////////////////////////////////////////////////////////////////
123 // Magnifier
124 ///////////////////////////////////////////////////////////////////////////////////////////////////
125
126 Dali::Toolkit::Magnifier Magnifier::New()
127 {
128   // Create the implementation
129   MagnifierPtr magnifier(new Magnifier());
130
131   // Pass ownership to CustomActor via derived handle
132   Dali::Toolkit::Magnifier handle(*magnifier);
133
134   // Second-phase init of the implementation
135   // This can only be done after the CustomActor connection has been made...
136   magnifier->Initialize();
137
138   return handle;
139 }
140
141 Magnifier::Magnifier()
142 : Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS ) ),
143   mDefaultCameraDistance(1000.f),
144   mActorSize(Vector3::ZERO),
145   mMagnificationFactor(1.0f)
146 {
147 }
148
149 void Magnifier::SetSourceActor(Actor actor)
150 {
151   mTask.SetSourceActor( actor );
152 }
153
154 void Magnifier::Initialize()
155 {
156   Actor self = Self();
157   Vector2 stageSize(Stage::GetCurrent().GetSize());
158
159   // NOTE:
160   // sourceActor is a dummy delegate actor that takes the source property position,
161   // and generates a WORLD_POSITION, which is 1 frame behind the source property.
162   // This way the constraints for determining the camera position (source) and those
163   // for determining viewport position use the same 1 frame old values.
164   // A simple i) CameraPos = f(B), ii) B = f(A) set of constraints wont suffice as
165   // although CameraPos will use B, which is A's previous value. The constraint will
166   // not realise that B is still dirty as far as constraint (i) is concerned.
167   // Perhaps this is a bug in the way the constraint system factors into what is dirty
168   // and what is not.
169   mSourceActor = Actor::New();
170   Stage().GetCurrent().Add(mSourceActor);
171   mSourceActor.SetParentOrigin(ParentOrigin::CENTER);
172   Constraint constraint = Constraint::New<Vector3>( mSourceActor, Actor::Property::POSITION, EqualToConstraint() );
173   constraint.AddSource( Source( self, Toolkit::Magnifier::Property::SOURCE_POSITION ) );
174   constraint.Apply();
175
176   // create the render task this will render content on top of everything
177   // based on camera source position.
178   InitializeRenderTask();
179
180   // set up some constraints to:
181   // i) reposition (dest) frame actor based on magnifier actor's world position (this is 1 frame delayed)
182   // ii) reposition and resize (dest) the render task's viewport based on magnifier actor's world position (1 frame delayed) & size.
183   // iii) reposition (source) camera actor based on magnifier source actor's world position (this is 1 frame delayed)
184
185   // Apply constraint to camera's position
186   // Position our camera at the same distance from its target as the default camera is.
187   // The camera position doesn't affect how we render, just what we render (due to near and far clip planes)
188   // NOTE: We can't interrogate the default camera's position as it is not known initially (takes 1 frame
189   // for value to update).
190   // But we can determine the initial position using the same formula:
191   // distance = stage.height * 0.5 / tan(FOV * 0.5)
192
193   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
194   RenderTask renderTask = taskList.GetTask(0u);
195   float fov = renderTask.GetCameraActor().GetFieldOfView();
196   mDefaultCameraDistance = (stageSize.height * 0.5f) / tanf(fov * 0.5f);
197
198   // Use a 1 frame delayed source position to determine the camera actor's position.
199   // This is necessary as the viewport is determined by the Magnifier's Actor's World position (which is computed
200   // at the end of the update cycle i.e. after constraints have been applied.)
201   //Property::Index propertySourcePositionDelayed = mCameraActor.RegisterProperty("delayed-source-position", Vector3::ZERO);
202
203   constraint = Constraint::New<Vector3>( mCameraActor, Actor::Property::POSITION, CameraActorPositionConstraint(stageSize, mDefaultCameraDistance) );
204   constraint.AddSource( Source( mSourceActor, Actor::Property::WORLD_POSITION ) );
205   constraint.Apply();
206
207   // Apply constraint to render-task viewport position
208   constraint = Constraint::New<Vector2>( mTask, RenderTask::Property::VIEWPORT_POSITION, RenderTaskViewportPositionConstraint(stageSize) );
209   constraint.AddSource( Source( self, Actor::Property::WORLD_POSITION ) );
210   constraint.AddSource( Source( self, Actor::Property::SIZE ) );
211   constraint.AddSource( Source( self, Actor::Property::WORLD_SCALE ) );
212   constraint.Apply();
213
214   // Apply constraint to render-task viewport position
215   constraint = Constraint::New<Vector2>( mTask, RenderTask::Property::VIEWPORT_SIZE, RenderTaskViewportSizeConstraint() );
216   constraint.AddSource( Source( self, Actor::Property::SIZE ) );
217   constraint.AddSource( Source( self, Actor::Property::WORLD_SCALE ) );
218   constraint.Apply();
219 }
220
221 Magnifier::~Magnifier()
222 {
223
224 }
225
226 void Magnifier::InitializeRenderTask()
227 {
228   Stage stage = Stage::GetCurrent();
229
230   RenderTaskList taskList = stage.GetRenderTaskList();
231
232   mTask = taskList.CreateTask();
233   mTask.SetInputEnabled(false);
234   mTask.SetClearColor(Vector4(0.5f, 0.5f, 0.5f, 1.0f));
235   mTask.SetClearEnabled(true);
236
237   mCameraActor = CameraActor::New();
238   mCameraActor.SetType(Camera::FREE_LOOK);
239
240   stage.Add(mCameraActor);
241   mTask.SetCameraActor( mCameraActor );
242
243   SetFrameVisibility(true);
244 }
245
246 bool Magnifier::GetFrameVisibility() const
247 {
248   return mFrame;
249 }
250
251 void Magnifier::SetFrameVisibility(bool visible)
252 {
253   if(visible && !mFrame)
254   {
255     Actor self(Self());
256
257     mFrame = Actor::New( );
258     mFrame.SetPositionInheritanceMode(DONT_INHERIT_POSITION);
259     mFrame.SetInheritScale(true);
260     mFrame.SetResizePolicy( ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT, Dimension::ALL_DIMENSIONS );
261     Vector3 sizeOffset(IMAGE_BORDER_INDENT*2.f - 2.f, IMAGE_BORDER_INDENT*2.f - 2.f, 0.0f);
262     mFrame.SetSizeModeFactor( sizeOffset );
263
264     //TODO Set the renderer onto the control self when Actor::RemoveRenderer is supported
265     Toolkit::RendererFactory rendererFactory = Toolkit::RendererFactory::Get();
266     Toolkit::ControlRenderer borderRenderer = rendererFactory.GetControlRenderer(IMAGE_BORDER_INDENT, Color::WHITE);
267     borderRenderer.SetOnStage( mFrame );
268
269     Constraint constraint = Constraint::New<Vector3>( mFrame, Actor::Property::POSITION, EqualToConstraint() );
270     constraint.AddSource( ParentSource( Actor::Property::WORLD_POSITION ) );
271     constraint.Apply();
272
273     self.Add(mFrame);
274   }
275   else if(!visible && mFrame)
276   {
277     UnparentAndReset(mFrame);
278   }
279 }
280
281 void Magnifier::OnSizeSet(const Vector3& targetSize)
282 {
283   // TODO: Once Camera/CameraActor properties function as proper animatable properties
284   // this code can disappear.
285   // whenever the size of the magnifier changes, the field of view needs to change
286   // to compensate for the new size of the viewport. this cannot be done within
287   // a constraint yet as Camera/CameraActor properties are not animatable/constrainable.
288   mActorSize = targetSize;
289   Update();
290 }
291
292 float Magnifier::GetMagnificationFactor() const
293 {
294   return mMagnificationFactor;
295 }
296
297 void Magnifier::SetMagnificationFactor(float value)
298 {
299   mMagnificationFactor = value;
300   Update();
301 }
302
303 void Magnifier::Update()
304 {
305   // TODO: Make Camera settings (fieldofview/aspectratio) as animatable constraints.
306
307   // should be updated when:
308   // Magnifier's world size/scale changes.
309   Actor self(Self());
310   Vector3 worldSize = mActorSize * self.GetCurrentWorldScale();
311
312   // Adjust field of view to scale content
313
314   // size.height / 2
315   // |------/
316   // |d    /
317   // |i   /
318   // |s  /
319   // |t /
320   // |./
321   // |/ <--- fov/2 radians.
322   //
323   const float fov = atanf( 0.5f * worldSize.height / mDefaultCameraDistance / mMagnificationFactor) * 2.0f;
324   mCameraActor.SetFieldOfView( fov );
325
326   // Adjust aspect ratio to compensate for rectangular viewports.
327   mCameraActor.SetAspectRatio( worldSize.width / worldSize.height );
328 }
329
330 void Magnifier::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
331 {
332   Toolkit::Magnifier magnifier = Toolkit::Magnifier::DownCast( Dali::BaseHandle( object ) );
333
334   if( magnifier )
335   {
336     Magnifier& magnifierImpl( GetImpl( magnifier ) );
337     switch( index )
338     {
339       case Toolkit::Magnifier::Property::FRAME_VISIBILITY:
340       {
341         magnifierImpl.SetFrameVisibility( value.Get< bool >() );
342         break;
343       }
344       case Toolkit::Magnifier::Property::MAGNIFICATION_FACTOR:
345       {
346         magnifierImpl.SetMagnificationFactor( value.Get< float >() );
347         break;
348       }
349     }
350   }
351 }
352
353 Property::Value Magnifier::GetProperty( BaseObject* object, Property::Index index )
354 {
355   Property::Value value;
356
357   Toolkit::Magnifier magnifier = Toolkit::Magnifier::DownCast( Dali::BaseHandle( object ) );
358
359   if( magnifier )
360   {
361     Magnifier& magnifierImpl( GetImpl( magnifier ) );
362     switch( index )
363     {
364       case Toolkit::Magnifier::Property::FRAME_VISIBILITY:
365       {
366         value = magnifierImpl.GetFrameVisibility();
367         break;
368       }
369       case Toolkit::Magnifier::Property::MAGNIFICATION_FACTOR:
370       {
371         value = magnifierImpl.GetMagnificationFactor();
372         break;
373       }
374     }
375   }
376
377   return value;
378 }
379
380 } // namespace Internal
381
382 } // namespace Toolkit
383
384 } // namespace Dali