2 * Copyright (c) 2020 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
21 #include <dali/public-api/dali-core.h>
22 #include <dali/integration-api/events/touch-integ.h>
23 #include <dali/integration-api/events/touch-event-integ.h>
24 #include <dali/integration-api/render-task-list-integ.h>
25 #include <dali-test-suite-utils.h>
26 #include <dali/devel-api/actors/actor-devel.h>
30 void utc_dali_touch_processing_startup(void)
32 test_return_value = TET_UNDEF;
35 void utc_dali_touch_processing_cleanup(void)
37 test_return_value = TET_PASS;
40 ///////////////////////////////////////////////////////////////////////////////
47 PointState::Type state{PointState::FINISHED};
52 Vector2 ellipseRadius;
55 Device::Class::Type deviceClass{Device::Class::NONE};
56 Device::Subclass::Type deviceSubclass{Device::Subclass::NONE};
58 TestPoint() = default;
59 static const TestPoint ZERO;
62 const TestPoint TestPoint::ZERO;
65 // Stores data that is populated in the callback and will be read by the TET cases
69 : functorCalled( false ),
78 std::vector<TestPoint> points;
80 const TestPoint& GetPoint(size_t i)
82 if( i < points.size() )
86 return TestPoint::ZERO;
88 size_t GetPointCount()
96 functorCalled = false;
98 receivedTouch.time = 0u;
99 receivedTouch.points.clear();
101 touchedActor.Reset();
105 TestTouchEvent receivedTouch;
109 // Functor that sets the data when called
110 struct TouchEventFunctor
114 * @param[in] data Reference to the data to store callback information.
115 * @param[in] returnValue What the functor should return.
117 TouchEventFunctor( SignalData& data, bool returnValue = true )
118 : signalData( data ),
119 returnValue( returnValue )
123 bool operator()( Actor actor, const TouchEvent& touch )
125 signalData.functorCalled = true;
126 signalData.touchedActor = actor;
128 signalData.receivedTouch.time = touch.GetTime();
129 signalData.receivedTouch.points.clear();
131 for( size_t i=0; i<touch.GetPointCount(); ++i )
134 p.deviceId = touch.GetDeviceId(i);
135 p.state = touch.GetState(i);
136 p.hitActor = touch.GetHitActor(i);
137 p.local = touch.GetLocalPosition(i);
138 p.screen = touch.GetScreenPosition(i);
139 p.radius = touch.GetRadius(i);
140 p.ellipseRadius = touch.GetEllipseRadius(i);
141 p.pressure = touch.GetPressure(i);
142 p.angle = touch.GetAngle(i);
143 p.deviceClass = touch.GetDeviceClass(i);
144 p.deviceSubclass = touch.GetDeviceSubclass(i);
145 signalData.receivedTouch.points.push_back(p);
151 SignalData& signalData;
158 TouchEvent receivedTouchHandle;
161 : signalReceived(false)
166 struct TouchEventHandleFunctor
170 * @param[in] data Reference to the data to store callback information.
171 * @param[in] returnValue What the functor should return.
173 TouchEventHandleFunctor( HandleData& handleData, bool returnValue = true )
174 : handleData(handleData),
175 returnValue( returnValue )
179 bool operator()( Actor actor, const TouchEvent& someTouchEvent )
181 handleData.signalReceived = true;
182 handleData.receivedTouchHandle = someTouchEvent;
186 HandleData& handleData;
191 // Functor that removes the actor when called.
192 struct RemoveActorFunctor : public TouchEventFunctor
196 * @param[in] data Reference to the data to store callback information.
197 * @param[in] returnValue What the functor should return.
199 RemoveActorFunctor( SignalData& data, bool returnValue = true )
200 : TouchEventFunctor( data, returnValue )
204 bool operator()( Actor actor, const TouchEvent& touch )
206 Actor parent( actor.GetParent() );
209 parent.Remove( actor );
212 return TouchEventFunctor::operator()( actor, touch );
216 struct OutOfBoundsData
222 :functorCalled(false)
227 // Functor that reads out of bounds data when called
228 struct OutOfBoundsFunctor
232 * @param[in] data Reference to the data to store callback information.
233 * @param[in] returnValue What the functor should return.
235 OutOfBoundsFunctor( OutOfBoundsData& data, bool returnValue = true )
236 : outOfBoundsData ( data ),
237 returnValue( returnValue )
241 bool operator()( Actor actor, const TouchEvent& touch )
243 outOfBoundsData.functorCalled = true;
244 size_t count = touch.GetPointCount();
246 // Read out of bounds data
247 outOfBoundsData.point.deviceId = touch.GetDeviceId(count+1);
248 outOfBoundsData.point.state = touch.GetState(count+1);
249 outOfBoundsData.point.hitActor = touch.GetHitActor(count+1);
250 outOfBoundsData.point.local = touch.GetLocalPosition(count+1);
251 outOfBoundsData.point.screen = touch.GetScreenPosition(count+1);
256 OutOfBoundsData& outOfBoundsData;
260 Integration::TouchEvent GenerateSingleTouch( PointState::Type state, const Vector2& screenPosition )
262 Integration::TouchEvent touchEvent;
263 Integration::Point point;
264 point.SetState( state );
265 point.SetScreenPosition( screenPosition );
266 point.SetDeviceClass( Device::Class::TOUCH );
267 point.SetDeviceSubclass( Device::Subclass::NONE );
268 touchEvent.points.push_back( point );
274 ///////////////////////////////////////////////////////////////////////////////
276 int UtcDaliTouchEventNormalProcessing01(void)
278 TestApplication application;
280 Actor actor = Actor::New();
281 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
282 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
283 application.GetScene().Add(actor);
286 application.SendNotification();
287 application.Render();
289 // Connect to actor's touch signal
291 TouchEventFunctor functor( data );
292 actor.TouchedSignal().Connect( &application, functor );
294 Vector2 screenCoordinates( 10.0f, 10.0f );
295 Vector2 localCoordinates;
296 actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
298 // Emit a down signal
299 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
300 const TestPoint *point1 = &data.receivedTouch.GetPoint(0);
301 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
302 DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
303 DALI_TEST_EQUALS( PointState::DOWN, point1->state, TEST_LOCATION );
304 DALI_TEST_EQUALS( screenCoordinates, point1->screen, TEST_LOCATION );
305 DALI_TEST_EQUALS( localCoordinates, point1->local, 0.1f, TEST_LOCATION );
308 // Emit a motion signal
309 screenCoordinates.x = screenCoordinates.y = 11.0f;
310 actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
311 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, screenCoordinates ) );
312 const TestPoint *point2 = &data.receivedTouch.GetPoint(0);
313 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
314 DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
315 DALI_TEST_EQUALS( PointState::MOTION, point2->state, TEST_LOCATION );
316 DALI_TEST_EQUALS( screenCoordinates, point2->screen, TEST_LOCATION );
317 DALI_TEST_EQUALS( localCoordinates, point2->local, 0.1f, TEST_LOCATION );
321 screenCoordinates.x = screenCoordinates.y = 12.0f;
322 actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
323 application.ProcessEvent( GenerateSingleTouch( PointState::UP, screenCoordinates ) );
324 const TestPoint *point3 = &data.receivedTouch.GetPoint(0);
325 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
326 DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
327 DALI_TEST_EQUALS( PointState::UP, point3->state, TEST_LOCATION );
328 DALI_TEST_EQUALS( screenCoordinates, point3->screen, TEST_LOCATION );
329 DALI_TEST_EQUALS( localCoordinates, point3->local, 0.1f, TEST_LOCATION );
332 // Emit a down signal where the actor is not present
333 screenCoordinates.x = screenCoordinates.y = 200.0f;
334 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
335 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
340 int UtcDaliTouchEventNormalProcessing02(void)
342 TestApplication application;
344 Actor actor = Actor::New();
345 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
346 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
347 application.GetScene().Add(actor);
350 application.SendNotification();
351 application.Render();
353 // Connect to actor's touched signal
354 HandleData handleData;
355 TouchEventHandleFunctor functor( handleData );
356 actor.TouchedSignal().Connect( &application, functor );
358 Vector2 screenCoordinates( 10.0f, 10.0f );
359 Vector2 localCoordinates;
360 actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
362 // Emit a down signal
363 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
364 DALI_TEST_EQUALS( true, handleData.signalReceived, TEST_LOCATION );
365 DALI_TEST_EQUALS( 1u, handleData.receivedTouchHandle.GetPointCount(), TEST_LOCATION );
366 DALI_TEST_EQUALS( PointState::DOWN, handleData.receivedTouchHandle.GetState(0), TEST_LOCATION );
367 DALI_TEST_EQUALS( screenCoordinates, handleData.receivedTouchHandle.GetScreenPosition(0), TEST_LOCATION );
368 DALI_TEST_EQUALS( localCoordinates, handleData.receivedTouchHandle.GetLocalPosition(0), 0.1f, TEST_LOCATION );
374 int UtcDaliTouchEventAPINegative(void)
376 TestApplication application;
378 Actor actor = Actor::New();
379 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
380 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
381 application.GetScene().Add(actor);
384 application.SendNotification();
385 application.Render();
387 // Connect to actor's touched signal
388 OutOfBoundsData data;
389 OutOfBoundsFunctor functor( data, true );
390 actor.TouchedSignal().Connect( &application, functor );
392 Vector2 screenCoordinates( 10.0f, 10.0f );
393 Vector2 localCoordinates;
394 actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
396 // Emit a down signal
397 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
399 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
400 DALI_TEST_EQUALS( -1, data.point.deviceId, TEST_LOCATION );
401 DALI_TEST_EQUALS( PointState::FINISHED, data.point.state, TEST_LOCATION );
402 DALI_TEST_EQUALS( Vector2::ZERO, data.point.screen, TEST_LOCATION );
403 DALI_TEST_EQUALS( Vector2::ZERO, data.point.local, 0.1f, TEST_LOCATION );
404 DALI_TEST_CHECK( ! data.point.hitActor );
410 int UtcDaliTouchEventOutsideCameraNearFarPlanes(void)
412 TestApplication application;
414 Integration::Scene scene = application.GetScene();
415 Vector2 sceneSize = scene.GetSize();
417 Actor actor = Actor::New();
418 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
419 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
420 actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
424 application.SendNotification();
425 application.Render();
427 // Get the camera's near and far planes
428 RenderTaskList taskList = scene.GetRenderTaskList();
429 Dali::RenderTask task = taskList.GetTask(0);
430 CameraActor camera = task.GetCameraActor();
431 float nearPlane = camera.GetNearClippingPlane();
432 float farPlane = camera.GetFarClippingPlane();
434 // Calculate the current distance of the actor from the camera
435 float tanHalfFov = tanf(camera.GetFieldOfView() * 0.5f);
436 float distance = (sceneSize.y * 0.5f) / tanHalfFov;
438 // Connect to actor's touched signal
440 TouchEventFunctor functor( data );
441 actor.TouchedSignal().Connect( &application, functor );
443 Vector2 screenCoordinates( sceneSize.x * 0.5f, sceneSize.y * 0.5f );
445 // Emit a down signal
446 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
447 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
450 // Emit a down signal where actor is just at the camera's near plane
451 actor.SetProperty( Actor::Property::POSITION_Z, distance - nearPlane);
454 application.SendNotification();
455 application.Render();
457 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
458 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
461 // Emit a down signal where actor is closer than the camera's near plane
462 actor.SetProperty( Actor::Property::POSITION_Z, (distance - nearPlane) + 1.0f);
465 application.SendNotification();
466 application.Render();
468 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
469 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
472 // Emit a down signal where actor is just at the camera's far plane
473 actor.SetProperty( Actor::Property::POSITION_Z, distance - farPlane);
476 application.SendNotification();
477 application.Render();
479 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
480 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
483 // Emit a down signal where actor is further than the camera's far plane
484 actor.SetProperty( Actor::Property::POSITION_Z, (distance - farPlane) - 1.0f);
487 application.SendNotification();
488 application.Render();
490 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
491 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
496 int UtcDaliTouchEventEmitEmpty(void)
498 TestApplication application;
502 // Emit an empty TouchEvent
503 Integration::TouchEvent event;
504 application.ProcessEvent( event );
505 tet_result( TET_FAIL );
507 catch ( Dali::DaliException& e )
509 DALI_TEST_ASSERT( e, "!event.points.empty()", TEST_LOCATION );
514 int UtcDaliTouchEventInterrupted(void)
516 TestApplication application;
518 Actor actor = Actor::New();
519 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
520 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
521 application.GetScene().Add(actor);
524 application.SendNotification();
525 application.Render();
527 // Connect to actor's touched signal
529 TouchEventFunctor functor( data );
530 actor.TouchedSignal().Connect( &application, functor );
532 // Emit a down signal
533 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
534 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
535 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
538 // Emit an interrupted signal, we should be signalled regardless of whether there is a hit or not.
539 application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
540 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
541 DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
544 // Emit another interrupted signal, our signal handler should not be called.
545 application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f ) ) );
546 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
550 int UtcDaliTouchEventParentConsumer(void)
552 TestApplication application;
553 Actor rootActor( application.GetScene().GetRootLayer() );
555 Actor actor = Actor::New();
556 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
557 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
558 application.GetScene().Add(actor);
561 application.SendNotification();
562 application.Render();
564 // Connect to actor's touched signal
566 TouchEventFunctor functor( data, false );
567 actor.TouchedSignal().Connect( &application, functor );
569 // Connect to root actor's touched signal
571 TouchEventFunctor rootFunctor( rootData ); // Consumes signal
572 rootActor.TouchedSignal().Connect( &application, rootFunctor );
574 Vector2 screenCoordinates( 10.0f, 10.0f );
575 Vector2 actorCoordinates, rootCoordinates;
576 actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
577 rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
579 // Emit a down signal
580 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
581 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
582 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
583 DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
584 DALI_TEST_EQUALS( 1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION );
585 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
586 DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
587 DALI_TEST_EQUALS( screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION );
588 DALI_TEST_EQUALS( screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION );
589 DALI_TEST_EQUALS( actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
590 DALI_TEST_EQUALS( rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
591 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
592 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
596 // Emit a motion signal
597 screenCoordinates.x = screenCoordinates.y = 11.0f;
598 actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
599 rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
600 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, screenCoordinates ) );
601 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
602 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
603 DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
604 DALI_TEST_EQUALS( 1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION );
605 DALI_TEST_EQUALS( PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION );
606 DALI_TEST_EQUALS( PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION );
607 DALI_TEST_EQUALS( screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION );
608 DALI_TEST_EQUALS( screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION );
609 DALI_TEST_EQUALS( actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
610 DALI_TEST_EQUALS( rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
611 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
612 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
617 screenCoordinates.x = screenCoordinates.y = 12.0f;
618 actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
619 rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
620 application.ProcessEvent( GenerateSingleTouch( PointState::UP, screenCoordinates ) );
621 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
622 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
623 DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
624 DALI_TEST_EQUALS( 1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION );
625 DALI_TEST_EQUALS( PointState::UP, data.receivedTouch.points[0].state, TEST_LOCATION );
626 DALI_TEST_EQUALS( PointState::UP, rootData.receivedTouch.points[0].state, TEST_LOCATION );
627 DALI_TEST_EQUALS( screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION );
628 DALI_TEST_EQUALS( screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION );
629 DALI_TEST_EQUALS( actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
630 DALI_TEST_EQUALS( rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
631 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
632 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
636 // Emit a down signal where the actor is not present, will hit the root actor though
637 screenCoordinates.x = screenCoordinates.y = 200.0f;
638 rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
639 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
640 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
641 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
642 DALI_TEST_EQUALS( 1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION );
643 DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
644 DALI_TEST_EQUALS( screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION );
645 DALI_TEST_EQUALS( rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
646 DALI_TEST_CHECK( rootActor == rootData.receivedTouch.points[0].hitActor );
650 int UtcDaliTouchEventInterruptedParentConsumer(void)
652 TestApplication application;
653 Actor rootActor( application.GetScene().GetRootLayer() );
655 Actor actor = Actor::New();
656 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
657 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
658 application.GetScene().Add(actor);
661 application.SendNotification();
662 application.Render();
664 // Connect to actor's touched signal
666 TouchEventFunctor functor( data, false );
667 actor.TouchedSignal().Connect( &application, functor );
669 // Connect to root actor's touched signal
671 TouchEventFunctor rootFunctor( rootData ); // Consumes signal
672 rootActor.TouchedSignal().Connect( &application, rootFunctor );
674 // Emit a down signal
675 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
676 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
677 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
678 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
679 DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
680 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
681 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
685 // Emit an interrupted signal
686 application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f ) ) );
687 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
688 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
689 DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
690 DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
691 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
692 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
696 // Emit another down signal
697 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
698 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
699 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
700 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
701 DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
705 // Remove actor from scene
706 application.GetScene().Remove( actor );
711 application.SendNotification();
712 application.Render();
714 // Emit an interrupted signal, only root actor's signal should be called.
715 application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
716 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
717 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
718 DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
719 DALI_TEST_CHECK( rootActor == rootData.receivedTouch.points[0].hitActor );
723 // Emit another interrupted state, none of the signal's should be called.
724 application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f ) ) );
725 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
726 DALI_TEST_EQUALS( false, rootData.functorCalled, TEST_LOCATION );
730 int UtcDaliTouchEventLeave(void)
732 TestApplication application;
734 Actor actor = Actor::New();
735 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
736 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
737 application.GetScene().Add(actor);
740 application.SendNotification();
741 application.Render();
743 // Connect to actor's touched signal
745 TouchEventFunctor functor( data );
746 actor.TouchedSignal().Connect( &application, functor );
748 // Set actor to require leave events
749 actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
751 // Emit a down signal
752 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
753 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
754 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
757 // Emit a motion signal outside of actor, should be signalled with a Leave
758 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
759 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
760 DALI_TEST_EQUALS( PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION );
763 // Another motion outside of actor, no signalling
764 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 201.0f, 201.0f )) );
765 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
768 // Another motion event inside actor, signalled with motion
769 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 10.0f, 10.0f )) );
770 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
771 DALI_TEST_EQUALS( PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION );
774 // We do not want to listen to leave events anymore
775 actor.SetProperty( Actor::Property::LEAVE_REQUIRED, false );
777 // Another motion event outside of actor, no signalling
778 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
779 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
784 int UtcDaliTouchEventLeaveParentConsumer(void)
786 TestApplication application;
787 Actor rootActor( application.GetScene().GetRootLayer() );
789 Actor actor = Actor::New();
790 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
791 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
792 application.GetScene().Add(actor);
795 application.SendNotification();
796 application.Render();
798 // Connect to actor's touched signal
800 TouchEventFunctor functor( data, false );
801 actor.TouchedSignal().Connect( &application, functor );
803 // Connect to root actor's touched signal
805 TouchEventFunctor rootFunctor( rootData ); // Consumes signal
806 rootActor.TouchedSignal().Connect( &application, rootFunctor );
808 // Set actor to require leave events
809 actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
810 rootActor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
812 // Emit a down signal
813 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
814 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
815 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
816 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
817 DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
818 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
819 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
823 // Emit a motion signal outside of actor, should be signalled with a Leave
824 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
825 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
826 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
827 DALI_TEST_EQUALS( PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION );
828 DALI_TEST_EQUALS( PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION );
829 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
830 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
834 // Another motion outside of actor, only rootActor signalled
835 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 201.0f, 201.0f )) );
836 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
837 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
838 DALI_TEST_EQUALS( PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION );
839 DALI_TEST_CHECK( rootActor == rootData.receivedTouch.points[0].hitActor );
843 // Another motion event inside actor, signalled with motion
844 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 10.0f, 10.0f )) );
845 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
846 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
847 DALI_TEST_EQUALS( PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION );
848 DALI_TEST_EQUALS( PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION );
849 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
850 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
854 // We do not want to listen to leave events of actor anymore
855 actor.SetProperty( Actor::Property::LEAVE_REQUIRED, false );
857 // Another motion event outside of root actor, only root signalled
858 Vector2 sceneSize( application.GetScene().GetSize() );
859 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( sceneSize.width + 10.0f, sceneSize.height + 10.0f )) );
860 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
861 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
862 DALI_TEST_EQUALS( PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION );
866 int UtcDaliTouchEventActorBecomesInsensitive(void)
868 TestApplication application;
870 Actor actor = Actor::New();
871 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
872 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
873 application.GetScene().Add(actor);
876 application.SendNotification();
877 application.Render();
879 // Connect to actor's touched signal
881 TouchEventFunctor functor( data );
882 actor.TouchedSignal().Connect( &application, functor );
884 // Emit a down signal
885 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
886 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
887 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
890 // Change actor to insensitive
891 actor.SetProperty( Actor::Property::SENSITIVE, false );
893 // Emit a motion signal, signalled with an interrupted
894 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
895 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
896 DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
901 int UtcDaliTouchEventActorBecomesInsensitiveParentConsumer(void)
903 TestApplication application;
904 Actor rootActor( application.GetScene().GetRootLayer() );
906 Actor actor = Actor::New();
907 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
908 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
909 application.GetScene().Add(actor);
912 application.SendNotification();
913 application.Render();
915 // Connect to actor's touched signal
917 TouchEventFunctor functor( data, false );
918 actor.TouchedSignal().Connect( &application, functor );
920 // Connect to root actor's touched signal
922 TouchEventFunctor rootFunctor( rootData ); // Consumes signal
923 rootActor.TouchedSignal().Connect( &application, rootFunctor );
925 // Emit a down signal
926 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
927 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
928 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
929 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
930 DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
931 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
932 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
937 application.SendNotification();
938 application.Render();
940 // Make root actor insensitive
941 rootActor.SetProperty( Actor::Property::SENSITIVE, false );
943 // Emit a motion signal, signalled with an interrupted (should get interrupted even if within root actor)
944 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
945 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
946 DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
947 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
948 DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
952 int UtcDaliTouchEventMultipleLayers(void)
954 TestApplication application;
955 Actor rootActor( application.GetScene().GetRootLayer() );
957 // Connect to actor's touched signal
959 TouchEventFunctor functor( data );
961 Layer layer1 ( Layer::New() );
962 layer1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
963 layer1.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
964 application.GetScene().Add( layer1 );
966 Actor actor1 ( Actor::New() );
967 actor1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
968 actor1.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
969 actor1.SetProperty( Actor::Property::POSITION_Z, 1.0f ); // Should hit actor1 in this layer
970 layer1.Add( actor1 );
973 application.SendNotification();
974 application.Render();
976 // Connect to layer1 and actor1
977 layer1.TouchedSignal().Connect( &application, functor );
978 actor1.TouchedSignal().Connect( &application, functor );
980 // Hit in hittable area, actor1 should be hit
981 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
982 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
983 DALI_TEST_CHECK( data.touchedActor == actor1 );
986 // Make layer1 insensitive, nothing should be hit
987 layer1.SetProperty( Actor::Property::SENSITIVE, false );
988 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
989 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
992 // Make layer1 sensitive again, again actor1 will be hit
993 layer1.SetProperty( Actor::Property::SENSITIVE, true );
994 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
995 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
996 DALI_TEST_CHECK( data.touchedActor == actor1 );
999 // Make rootActor insensitive, nothing should be hit
1000 rootActor.SetProperty( Actor::Property::SENSITIVE, false );
1001 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1002 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1005 // Make rootActor sensitive
1006 rootActor.SetProperty( Actor::Property::SENSITIVE, true );
1008 // Add another layer
1009 Layer layer2 ( Layer::New() );
1010 layer2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1011 layer2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1012 layer2.SetProperty( Actor::Property::POSITION_Z, 10.0f ); // Should hit layer2 in this layer rather than actor2
1013 application.GetScene().Add( layer2 );
1015 Actor actor2 ( Actor::New() );
1016 actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1017 actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1018 layer2.Add( actor2 );
1020 // Render and notify
1021 application.SendNotification();
1022 application.Render();
1024 // Connect to layer2 and actor2
1025 layer2.TouchedSignal().Connect( &application, functor );
1026 actor2.TouchedSignal().Connect( &application, functor );
1028 // Emit an event, should hit layer2
1029 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1030 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1031 //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
1034 // Make layer2 insensitive, should hit actor1
1035 layer2.SetProperty( Actor::Property::SENSITIVE, false );
1036 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1037 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1038 DALI_TEST_CHECK( data.touchedActor == actor1 );
1041 // Make layer2 sensitive again, should hit layer2
1042 layer2.SetProperty( Actor::Property::SENSITIVE, true );
1043 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1044 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1045 //DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
1048 // Make layer2 invisible, render and notify
1049 layer2.SetProperty( Actor::Property::VISIBLE, false );
1050 application.SendNotification();
1051 application.Render();
1053 // Should hit actor1
1054 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1055 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1056 DALI_TEST_CHECK( data.touchedActor == actor1 );
1059 // Make rootActor invisible, render and notify
1060 rootActor.SetProperty( Actor::Property::VISIBLE, false );
1061 application.SendNotification();
1062 application.Render();
1064 // Should not hit anything
1065 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1066 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1071 int UtcDaliTouchEventMultipleRenderTasks(void)
1073 TestApplication application;
1074 Integration::Scene scene ( application.GetScene() );
1075 Vector2 sceneSize ( scene.GetSize() );
1077 Actor actor = Actor::New();
1078 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1079 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1082 // Create render task
1083 Viewport viewport( sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f );
1084 RenderTask renderTask ( application.GetScene().GetRenderTaskList().CreateTask() );
1085 renderTask.SetViewport( viewport );
1086 renderTask.SetInputEnabled( true );
1088 // Render and notify
1089 application.SendNotification();
1090 application.Render();
1092 // Connect to actor's touched signal
1094 TouchEventFunctor functor( data );
1095 actor.TouchedSignal().Connect( &application, functor );
1097 // Emit a down signal
1098 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1099 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1102 // Ensure renderTask actor can be hit too.
1103 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
1104 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1107 // Disable input on renderTask, should not be hittable
1108 renderTask.SetInputEnabled( false );
1109 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
1110 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1115 int UtcDaliTouchEventMultipleRenderTasksWithChildLayer(void)
1117 TestApplication application;
1118 Integration::Scene scene ( application.GetScene() );
1119 Vector2 sceneSize ( scene.GetSize() );
1121 Actor actor = Actor::New();
1122 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1123 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1126 Layer layer = Layer::New();
1127 layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1128 layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1131 // Create render task
1132 Viewport viewport( sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f );
1133 RenderTask renderTask ( application.GetScene().GetRenderTaskList().CreateTask() );
1134 renderTask.SetViewport( viewport );
1135 renderTask.SetInputEnabled( true );
1136 renderTask.SetSourceActor( actor );
1138 // Render and notify
1139 application.SendNotification();
1140 application.Render();
1142 // Connect to layer's touched signal
1144 TouchEventFunctor functor( data );
1145 actor.TouchedSignal().Connect( &application, functor );
1146 layer.TouchedSignal().Connect( &application, functor );
1148 // Emit a down signal
1149 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1150 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1153 // Ensure renderTask actor can be hit too.
1154 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
1155 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1158 // Disable input on renderTask, should not be hittable
1159 renderTask.SetInputEnabled( false );
1160 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
1161 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1166 int UtcDaliTouchEventOffscreenRenderTasks(void)
1168 TestApplication application;
1169 Integration::Scene scene ( application.GetScene() );
1170 Vector2 sceneSize ( scene.GetSize() );
1172 // FrameBufferImage for offscreen RenderTask
1173 FrameBuffer frameBuffer = FrameBuffer::New(sceneSize.width, sceneSize.height);
1175 // Create a renderable actor to display the FrameBufferImage
1176 Actor renderableActor = CreateRenderableActor(frameBuffer.GetColorTexture());
1177 renderableActor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1178 renderableActor.SetProperty( Actor::Property::SIZE, Vector2( sceneSize.x, sceneSize.y ) );
1179 renderableActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
1180 scene.Add( renderableActor );
1182 Actor actor = Actor::New();
1183 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1184 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1186 application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE ); // Ensure framebuffer connects
1188 scene.GetRenderTaskList().GetTask( 0u ).SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
1190 // Create a RenderTask
1191 RenderTask renderTask = scene.GetRenderTaskList().CreateTask();
1192 renderTask.SetSourceActor( actor );
1193 renderTask.SetFrameBuffer(frameBuffer);
1194 renderTask.SetInputEnabled( true );
1196 // Create another RenderTask
1197 RenderTask renderTask2( scene.GetRenderTaskList().CreateTask() );
1198 renderTask2.SetInputEnabled( true );
1200 // Render and notify
1201 application.SendNotification();
1202 application.Render();
1204 // Connect to actor's touched signal
1206 TouchEventFunctor functor( data );
1207 actor.TouchedSignal().Connect( &application, functor );
1209 // Emit a down signal
1210 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1211 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1216 int UtcDaliTouchEventMultipleRenderableActors(void)
1218 TestApplication application;
1219 Integration::Scene scene ( application.GetScene() );
1220 Vector2 sceneSize ( scene.GetSize() );
1222 Actor parent = CreateRenderableActor();
1223 parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1224 parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1227 Actor actor = CreateRenderableActor();
1228 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1229 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1232 // Render and notify
1233 application.SendNotification();
1234 application.Render();
1236 // Connect to layer's touched signal
1238 TouchEventFunctor functor( data );
1239 parent.TouchedSignal().Connect( &application, functor );
1240 actor.TouchedSignal().Connect( &application, functor );
1242 // Emit a down signal
1243 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1244 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1245 DALI_TEST_CHECK( actor == data.touchedActor );
1249 int UtcDaliTouchEventActorRemovedInSignal(void)
1251 TestApplication application;
1253 Actor actor = Actor::New();
1254 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1255 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1256 application.GetScene().Add(actor);
1258 // Render and notify
1259 application.SendNotification();
1260 application.Render();
1262 // Connect to actor's touched signal
1264 RemoveActorFunctor functor( data );
1265 actor.TouchedSignal().Connect( &application, functor );
1267 // Register for leave events
1268 actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
1270 // Emit a down signal
1271 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1272 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1275 // Re-add, render and notify
1276 application.GetScene().Add(actor);
1277 application.SendNotification();
1278 application.Render();
1280 // Emit another signal outside of actor's area, should not get anything as the scene has changed.
1281 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 210.0f, 210.0f ) ) );
1282 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1285 // Emit a down signal
1286 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1287 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1290 // Render and notify
1291 application.SendNotification();
1292 application.Render();
1294 // Emit another signal outside of actor's area, should not get anything as the scene has changed.
1295 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 210.0f, 210.0f ) ) );
1296 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1299 // Re-add actor back to scene, render and notify
1300 application.GetScene().Add(actor);
1301 application.SendNotification();
1302 application.Render();
1304 // Emit another down event
1305 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1306 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1309 // Completely delete the actor
1312 // Emit event, should not crash and should not receive an event.
1313 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 210.0f, 210.0f ) ) );
1314 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1318 int UtcDaliTouchEventActorSignalNotConsumed(void)
1320 TestApplication application;
1322 Actor actor = Actor::New();
1323 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1324 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1325 application.GetScene().Add(actor);
1327 // Render and notify
1328 application.SendNotification();
1329 application.Render();
1331 // Connect to actor's touched signal
1333 TouchEventFunctor functor( data, false );
1334 actor.TouchedSignal().Connect( &application, functor );
1336 // Emit a down signal
1337 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1338 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1342 int UtcDaliTouchEventActorRemovedFromScene(void)
1344 TestApplication application;
1346 Actor actor = Actor::New();
1347 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1348 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1349 application.GetScene().Add(actor);
1351 // Render and notify
1352 application.SendNotification();
1353 application.Render();
1355 // Connect to actor's touched signal
1357 TouchEventFunctor functor( data );
1358 actor.TouchedSignal().Connect( &application, functor );
1360 // Emit a down signal
1361 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1362 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1365 // Remove actor from scene
1366 application.GetScene().Remove( actor );
1369 // Render and notify
1370 application.SendNotification();
1371 application.Render();
1373 // Emit a move at the same point, we should not be signalled.
1374 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 10.0f, 10.0f ) ) );
1375 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1380 int UtcDaliTouchEventLayerConsumesTouch(void)
1382 TestApplication application;
1384 Actor actor = Actor::New();
1385 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1386 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1387 application.GetScene().Add(actor);
1389 // Render and notify
1390 application.SendNotification();
1391 application.Render();
1393 // Connect to actor's touched signal
1395 TouchEventFunctor functor( data );
1396 actor.TouchedSignal().Connect( &application, functor );
1398 // Add a layer to overlap the actor
1399 Layer layer = Layer::New();
1400 layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1401 layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1402 application.GetScene().Add( layer );
1405 // Render and notify
1406 application.SendNotification();
1407 application.Render();
1409 // Emit a few touch signals
1410 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1411 application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 10.0f, 10.0f ) ) );
1412 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1415 // Set layer to consume all touch
1416 layer.SetProperty( Layer::Property::CONSUMES_TOUCH, true );
1418 // Render and notify
1419 application.SendNotification();
1420 application.Render();
1422 // Emit the same signals again, should not receive
1423 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1424 application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 10.0f, 10.0f ) ) );
1425 DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
1431 int UtcDaliTouchEventLeaveActorReadded(void)
1433 TestApplication application;
1434 Integration::Scene scene = application.GetScene();
1436 Actor actor = Actor::New();
1437 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1438 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1441 // Set actor to receive touch-events
1442 actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
1444 // Render and notify
1445 application.SendNotification();
1446 application.Render();
1448 // Connect to actor's touched signal
1450 TouchEventFunctor functor( data );
1451 actor.TouchedSignal().Connect( &application, functor );
1453 // Emit a down and motion
1454 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1455 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 11.0f, 10.0f ) ) );
1456 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1459 // Remove actor from scene and add again
1460 scene.Remove( actor );
1463 // Emit a motion within the actor's bounds
1464 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 12.0f, 10.0f ) ) );
1465 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1468 // Emit a motion outside the actor's bounds
1469 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 200.0f, 200.0f ) ) );
1470 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1471 DALI_TEST_EQUALS( PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION );
1477 int UtcDaliTouchEventClippedActor(void)
1479 TestApplication application;
1480 Integration::Scene scene = application.GetScene();
1482 Actor actor = Actor::New();
1483 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1484 actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1487 Actor clippingActor = Actor::New();
1488 clippingActor.SetProperty( Actor::Property::SIZE, Vector2( 50.0f, 50.0f ) );
1489 clippingActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1490 clippingActor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
1491 scene.Add( clippingActor );
1493 // Add a child to the clipped region.
1494 Actor clippingChild = Actor::New();
1495 clippingChild.SetProperty( Actor::Property::SIZE, Vector2( 50.0f, 50.0f ) );
1496 clippingChild.SetProperty( Actor::Property::POSITION, Vector2( 25.0f, 25.0f ));
1497 clippingChild.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1498 clippingActor.Add( clippingChild );
1500 // Render and notify.
1501 application.SendNotification();
1502 application.Render();
1504 // Connect to actor's touch signal.
1506 TouchEventFunctor functor( data );
1507 actor.TouchedSignal().Connect( &application, functor );
1509 // Emit an event within clipped area - no hit.
1510 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1511 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1514 // Emit an event outside the clipped area but within the actor area, we should have a hit.
1515 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 60.0f, 60.0f ) ) );
1516 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1519 clippingChild.TouchedSignal().Connect( &application, functor );
1521 // Emit an event inside part of the child which is within the clipped area, we should have a hit.
1522 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 30.0f, 30.0f ) ) );
1523 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1529 int UtcDaliTouchEventActorUnparented(void)
1531 TestApplication application;
1533 Actor actor = Actor::New();
1534 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1535 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1536 application.GetScene().Add(actor);
1538 // Render and notify
1539 application.SendNotification();
1540 application.Render();
1542 // Connect to actor's touched signal
1544 TouchEventFunctor functor( data );
1545 actor.TouchedSignal().Connect( &application, functor );
1547 // Emit a down signal
1548 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1549 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1550 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
1551 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
1554 // Render and notify
1555 application.SendNotification();
1556 application.Render();
1558 // Unparent the actor
1561 // Should receive an interrupted event
1562 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1563 DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
1567 int UtcDaliTouchEventParentRemovedFromScene(void)
1569 TestApplication application;
1571 Actor parent = Actor::New();
1572 parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1573 parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1574 application.GetScene().Add(parent);
1576 Actor actor = Actor::New();
1577 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1578 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1581 // Render and notify
1582 application.SendNotification();
1583 application.Render();
1585 // Connect to actor's touched signal
1587 TouchEventFunctor functor( data );
1588 actor.TouchedSignal().Connect( &application, functor );
1590 // Emit a down signal
1591 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1592 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1593 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
1594 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
1597 // Render and notify
1598 application.SendNotification();
1599 application.Render();
1601 // Unparent the parent of the touchable actor
1604 // Should receive an interrupted event
1605 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1606 DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
1610 int UtcDaliTouchEventActorRemovedFromSceneDifferentConsumer(void)
1612 TestApplication application;
1614 Actor parent = Actor::New();
1615 parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1616 parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1617 application.GetScene().Add(parent);
1619 Actor actor = Actor::New();
1620 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1621 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1624 // Render and notify
1625 application.SendNotification();
1626 application.Render();
1628 // Connect to actor's touched signal
1630 TouchEventFunctor functor( data, false /* Do not consume */ );
1631 actor.TouchedSignal().Connect( &application, functor );
1633 // Connect to parent's touched signal
1634 SignalData parentData;
1635 TouchEventFunctor parentFunctor( parentData );
1636 parent.TouchedSignal().Connect( &application, parentFunctor );
1638 // Emit a down signal
1639 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1640 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1641 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
1642 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
1643 DALI_TEST_CHECK( actor == data.touchedActor );
1644 DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1645 DALI_TEST_EQUALS( PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION );
1646 DALI_TEST_CHECK( actor == parentData.receivedTouch.points[0].hitActor );
1647 DALI_TEST_CHECK( parent == parentData.touchedActor );
1651 // Render and notify
1652 application.SendNotification();
1653 application.Render();
1655 // Unparent the actor
1658 // Should receive an interrupted event for both actor & parent
1659 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1660 DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
1661 DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1662 DALI_TEST_EQUALS( PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION );
1666 // Readd actor to parent
1669 // Render and notify
1670 application.SendNotification();
1671 application.Render();
1673 // Emit a motion signal
1674 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 10.0f, 10.0f ) ) );
1675 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1676 DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1680 // Parent is now consumer, connect again to the touched signal of the actor so that it becomes the consumer
1681 SignalData secondData;
1682 TouchEventFunctor secondFunctor( secondData /* Consume */ );
1683 actor.TouchedSignal().Connect( &application, secondFunctor );
1685 // Unparent the actor
1688 // Should receive an interrupted event for both actor functors & the parent as well as it was last consumer
1689 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1690 DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
1691 DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1692 DALI_TEST_EQUALS( PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION );
1693 DALI_TEST_EQUALS( true, secondData.functorCalled, TEST_LOCATION );
1694 DALI_TEST_EQUALS( PointState::INTERRUPTED, secondData.receivedTouch.points[0].state, TEST_LOCATION );
1702 int UtcDaliTouchEventInterruptedDifferentConsumer(void)
1704 TestApplication application;
1705 Actor rootActor( application.GetScene().GetRootLayer() );
1707 Actor parent = Actor::New();
1708 parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1709 parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1710 application.GetScene().Add(parent);
1712 Actor actor = Actor::New();
1713 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1714 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1717 // Render and notify
1718 application.SendNotification();
1719 application.Render();
1721 // Connect to actor's touched signal
1723 TouchEventFunctor functor( data, false /* Do not consume */ );
1724 actor.TouchedSignal().Connect( &application, functor );
1726 // Connect to parent's touched signal
1727 SignalData parentData;
1728 TouchEventFunctor parentFunctor( parentData, false /* Do not consume */ );
1729 parent.TouchedSignal().Connect( &application, parentFunctor );
1731 // Connect to root's touched signal and consume
1732 SignalData rootData;
1733 TouchEventFunctor rootFunctor( rootData );
1734 rootActor.TouchedSignal().Connect( &application, rootFunctor );
1736 // Emit a down signal
1737 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1738 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1739 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
1740 DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
1741 DALI_TEST_CHECK( actor == data.touchedActor );
1742 DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1743 DALI_TEST_EQUALS( PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION );
1744 DALI_TEST_CHECK( actor == parentData.receivedTouch.points[0].hitActor );
1745 DALI_TEST_CHECK( parent == parentData.touchedActor );
1746 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
1747 DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
1748 DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
1749 DALI_TEST_CHECK( rootActor == rootData.touchedActor );
1754 // Root is now consumer, connect to the touched signal of the parent so that it becomes the consumer
1755 SignalData secondData;
1756 TouchEventFunctor secondFunctor( secondData /* Consume */ );
1757 parent.TouchedSignal().Connect( &application, secondFunctor );
1759 // Emit an interrupted signal, all three should STILL be called
1760 application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) ) );
1761 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1762 DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
1763 DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
1764 DALI_TEST_EQUALS( PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION );
1765 DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
1766 DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
1774 int UtcDaliTouchEventGetRadius(void)
1776 TestApplication application;
1778 Actor actor = Actor::New();
1779 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1780 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1781 application.GetScene().Add(actor);
1783 // Render and notify
1784 application.SendNotification();
1785 application.Render();
1787 // Connect to actor's touched signal
1789 TouchEventFunctor functor( data );
1790 actor.TouchedSignal().Connect( &application, functor );
1792 // Emit a down signal with an angle
1793 Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
1794 touchEvent.points[ 0 ].SetRadius( 100.0f );
1795 application.ProcessEvent( touchEvent );
1796 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1797 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
1798 DALI_TEST_EQUALS( 100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION );
1799 DALI_TEST_EQUALS( 100.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION );
1800 DALI_TEST_EQUALS( 100.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION );
1805 int UtcDaliTouchEventGetEllipseRadius(void)
1807 TestApplication application;
1809 Actor actor = Actor::New();
1810 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1811 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1812 application.GetScene().Add(actor);
1814 // Render and notify
1815 application.SendNotification();
1816 application.Render();
1818 // Connect to actor's touched signal
1820 TouchEventFunctor functor( data );
1821 actor.TouchedSignal().Connect( &application, functor );
1823 // Emit a down signal with an angle
1824 Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
1825 touchEvent.points[ 0 ].SetRadius( 100.0f, Vector2( 20.0f, 10.0f ) );
1826 application.ProcessEvent( touchEvent );
1827 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1828 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
1829 DALI_TEST_EQUALS( 100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION );
1830 DALI_TEST_EQUALS( 20.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION );
1831 DALI_TEST_EQUALS( 10.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION );
1836 int UtcDaliTouchEventGetAngle(void)
1838 TestApplication application;
1840 Actor actor = Actor::New();
1841 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1842 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1843 application.GetScene().Add(actor);
1845 // Render and notify
1846 application.SendNotification();
1847 application.Render();
1849 // Connect to actor's touched signal
1851 TouchEventFunctor functor( data );
1852 actor.TouchedSignal().Connect( &application, functor );
1854 // Emit a down signal with an angle
1855 Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
1856 touchEvent.points[ 0 ].SetAngle( Degree( 90.0f ) );
1857 application.ProcessEvent( touchEvent );
1858 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1859 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
1860 DALI_TEST_EQUALS( Degree( 90.0f ), data.receivedTouch.points[0].angle, TEST_LOCATION );
1865 int UtcDaliTouchEventGetPressure(void)
1867 TestApplication application;
1869 Actor actor = Actor::New();
1870 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1871 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1872 application.GetScene().Add(actor);
1874 // Render and notify
1875 application.SendNotification();
1876 application.Render();
1878 // Connect to actor's touched signal
1880 TouchEventFunctor functor( data );
1881 actor.TouchedSignal().Connect( &application, functor );
1883 // Emit a down signal with an angle
1884 Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
1885 touchEvent.points[ 0 ].SetPressure( 10.0f );
1886 application.ProcessEvent( touchEvent );
1887 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1888 DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
1889 DALI_TEST_EQUALS( 10.0f, data.receivedTouch.points[0].pressure, TEST_LOCATION );
1894 int UtcDaliTouchEventUsage(void)
1896 TestApplication application;
1898 Actor actor = Actor::New();
1899 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1900 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1901 application.GetScene().Add(actor);
1903 // Render and notify
1904 application.SendNotification();
1905 application.Render();
1907 // Connect to actor's touched signal
1909 TouchEventFunctor functor( data );
1910 actor.TouchedSignal().Connect( &application, functor );
1913 // Emit a down signal with an angle
1914 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
1915 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1921 int UtcDaliTouchEventGetDeviceAPINegative(void)
1923 TestApplication application;
1925 Actor actor = Actor::New();
1926 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1927 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1928 application.GetScene().Add(actor);
1930 // Render and notify
1931 application.SendNotification();
1932 application.Render();
1934 // Connect to actor's touched signal
1935 HandleData handleData;
1936 TouchEventHandleFunctor functor( handleData );
1937 actor.TouchedSignal().Connect( &application, functor );
1939 Vector2 screenCoordinates( 10.0f, 10.0f );
1940 Vector2 localCoordinates;
1941 actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
1943 // Emit a down signal
1944 application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
1946 TouchEvent data = handleData.receivedTouchHandle;
1947 DALI_TEST_EQUALS( data.GetDeviceClass( -1 ), Device::Class::NONE, TEST_LOCATION );
1948 DALI_TEST_EQUALS( data.GetDeviceSubclass( -1 ), Device::Subclass::NONE, TEST_LOCATION );
1952 int UtcDaliTouchEventGetMouseButtonPositive(void)
1954 TestApplication application;
1956 Actor actor = Actor::New();
1957 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1958 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1959 application.GetScene().Add(actor);
1961 // Render and notify
1962 application.SendNotification();
1963 application.Render();
1965 // Connect to actor's touched signal
1966 HandleData handleData;
1967 TouchEventHandleFunctor functor( handleData );
1968 actor.TouchedSignal().Connect( &application, functor );
1970 // Emit a down signal with MouseButton
1971 Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
1972 touchEvent.points[ 0 ].SetMouseButton( static_cast< MouseButton::Type >( 3 ) );
1973 application.ProcessEvent( touchEvent );
1975 TouchEvent data = handleData.receivedTouchHandle;
1976 DALI_TEST_EQUALS( data.GetMouseButton( 0 ), MouseButton::SECONDARY, TEST_LOCATION );
1981 int UtcDaliTouchEventGetMouseButtonNagative(void)
1983 TestApplication application;
1985 Actor actor = Actor::New();
1986 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
1987 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
1988 application.GetScene().Add(actor);
1990 // Render and notify
1991 application.SendNotification();
1992 application.Render();
1994 // Connect to actor's touched signal
1995 HandleData handleData;
1996 TouchEventHandleFunctor functor( handleData );
1997 actor.TouchedSignal().Connect( &application, functor );
1999 // Emit a down signal with MouseButton
2000 Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
2001 touchEvent.points[ 0 ].SetMouseButton( static_cast< MouseButton::Type >( 2 ) );
2002 application.ProcessEvent( touchEvent );
2004 TouchEvent data = handleData.receivedTouchHandle;
2005 DALI_TEST_EQUALS( data.GetMouseButton( 0 ), MouseButton::TERTIARY, TEST_LOCATION );
2006 DALI_TEST_EQUALS( data.GetMouseButton( 3 ), MouseButton::INVALID, TEST_LOCATION );
2011 int UtcDaliTouchEventCapturePropertySet(void)
2013 TestApplication application;
2015 Actor actor = Actor::New();
2016 actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
2017 actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
2018 application.GetScene().Add(actor);
2020 // Render and notify
2021 application.SendNotification();
2022 application.Render();
2024 // Connect to actor's touched signal
2026 TouchEventFunctor functor( data );
2027 actor.TouchedSignal().Connect( &application, functor );
2029 // Emit a down signal
2030 application.ProcessEvent( GenerateSingleTouch( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
2031 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
2034 // Now motion outside of actor, we should not receive the event
2035 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 110.0f, 110.0f ) ) );
2036 DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
2039 // Up event, should receive an interrupted
2040 application.ProcessEvent( GenerateSingleTouch( PointState::FINISHED, Vector2( 110.0f, 110.0f ) ) );
2041 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
2042 DALI_TEST_EQUALS( data.receivedTouch.GetPoint(0).state, PointState::INTERRUPTED, TEST_LOCATION );
2044 // Now set the capture property
2045 actor.SetProperty( DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true);
2047 // Emit a down signal
2048 application.ProcessEvent( GenerateSingleTouch( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
2049 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
2052 // Now motion outside of actor, we now SHOULD receive the event
2053 application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 110.0f, 110.0f ) ) );
2054 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
2057 // Up event, we should receive it again, but as ended rather than interrupted
2058 application.ProcessEvent( GenerateSingleTouch( PointState::FINISHED, Vector2( 110.0f, 110.0f ) ) );
2059 DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
2060 DALI_TEST_EQUALS( data.receivedTouch.GetPoint(0).state, PointState::FINISHED, TEST_LOCATION );
2065 int UtcDaliTouchEventIntegNewTouchEvent(void)
2067 uint32_t timestamp = 92858u;
2068 TouchPoint tp(1, PointState::STARTED, 34.4f, 123.89f, 5.0f, 7.0f);
2069 Dali::TouchEvent touchEvent = Integration::NewTouchEvent(timestamp, tp);
2071 DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
2072 DALI_TEST_EQUALS(touchEvent.GetState(0), PointState::STARTED, TEST_LOCATION );
2073 DALI_TEST_EQUALS(touchEvent.GetLocalPosition(0), Vector2(5.0f, 7.0f), TEST_LOCATION );
2074 DALI_TEST_EQUALS(touchEvent.GetScreenPosition(0), Vector2(34.4f, 123.89f), TEST_LOCATION );