Dali 3D User Interface Engine
utc-Dali-Stage.cpp
Go to the documentation of this file.
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 #include <iostream>
19 
20 #include <stdlib.h>
21 
27 
28 #include <dali-test-suite-utils.h>
29 
30 using namespace Dali;
31 
33 {
35 }
36 
38 {
40 }
41 
42 namespace
43 {
44 
45 // Functor for EventProcessingFinished signal
47 {
51  EventProcessingFinishedFunctor( bool& eventProcessingFinished )
52  : mEventProcessingFinished( eventProcessingFinished )
53  {}
54 
55  void operator()()
56  {
57  mEventProcessingFinished = true;
58  }
59 
61 };
62 
63 // Stores data that is populated in the key-event callback and will be read by the TET cases
65 {
67  : functorCalled(false)
68  {}
69 
70  void Reset()
71  {
72  functorCalled = false;
73 
74  receivedKeyEvent.keyModifier = 0;
75  receivedKeyEvent.keyPressedName.clear();
76  receivedKeyEvent.keyPressed.clear();
77  }
78 
81 };
82 
83 // Functor that sets the data when called
85 {
86  KeyEventReceivedFunctor( KeyEventSignalData& data ) : signalData( data ) { }
87 
88  bool operator()( const KeyEvent& keyEvent )
89  {
90  signalData.functorCalled = true;
91  signalData.receivedKeyEvent = keyEvent;
92 
93  return true;
94  }
95 
97 };
98 
99 // Stores data that is populated in the touched signal callback and will be read by the TET cases
101 {
103  : functorCalled(false)
104  {}
105 
106  void Reset()
107  {
108  functorCalled = false;
109 
110  receivedTouchEvent.points.clear();
111  receivedTouchEvent.time = 0;
112  }
113 
116 };
117 
118 // Functor that sets the data when touched signal is received
120 {
121  TouchedFunctor( TouchedSignalData& data ) : signalData( data ) { }
122 
123  void operator()( const TouchEvent& touch )
124  {
125  signalData.functorCalled = true;
126  signalData.receivedTouchEvent = touch;
127  }
128 
130 };
131 
132 // Stores data that is populated in the wheel-event callback and will be read by the TET cases
134 {
136  : functorCalled(false)
137  {}
138 
139  void Reset()
140  {
141  functorCalled = false;
142  }
143 
146 };
147 
148 // Functor that sets the data when wheel-event signal is received
150 {
151  WheelEventReceivedFunctor( WheelEventSignalData& data ) : signalData( data ) { }
152 
153  bool operator()( const WheelEvent& wheelEvent )
154  {
155  signalData.functorCalled = true;
156  signalData.receivedWheelEvent = wheelEvent;
157 
158  return true;
159  }
160 
162 };
163 
164 bool DummyTouchCallback( Actor actor, const TouchEvent& touch )
165 {
166  return true;
167 }
168 
170 {
171  ContextStatusFunctor(bool& calledFlag) : mCalledFlag( calledFlag )
172  {
173  mCalledFlag = false;
174  }
175 
176  void operator()()
177  {
178  mCalledFlag = true;
179  }
180  void Reset()
181  {
182  mCalledFlag = false;
183  }
184 
185  bool& mCalledFlag;
186 };
187 
189 {
190  SceneCreatedStatusFunctor(bool& calledFlag) : mCalledFlag( calledFlag )
191  {
192  mCalledFlag = false;
193  }
194 
195  void operator()()
196  {
197  mCalledFlag = true;
198  }
199  void Reset()
200  {
201  mCalledFlag = false;
202  }
203 
204  bool& mCalledFlag;
205 };
206 
208 {
209  ActorCreatedFunctor( bool& signalReceived )
210  : mSignalVerified( signalReceived )
211  {
212  }
213 
214  void operator()( BaseHandle object )
215  {
216  tet_infoline( "Verifying TestActorCallback()" );
217  Actor actor = Actor::DownCast( object );
218  if( actor )
219  {
220  mSignalVerified = true;
221  }
222  }
223 
225 };
226 
227 } // unnamed namespace
228 
229 
231 {
232  TestApplication application;
233  Stage stage;
234 
235  DALI_TEST_CHECK( !stage );
236  END_TEST;
237 }
238 
239 // Note: No negative test for default constructor.
240 
242 {
243  TestApplication application;
244  Stage* stage = new Stage();
245  delete stage;
246  stage = NULL;
247 
248  DALI_TEST_CHECK( true );
249  END_TEST;
250 }
251 
252 // Note: No negative test for default destructor.
253 
255 {
256  TestApplication application;
257  Stage stage = Stage::GetCurrent();
258 
259  DALI_TEST_CHECK( stage );
260  END_TEST;
261 }
262 
264 {
265  bool asserted = false;
266  try
267  {
268  Stage stage = Stage::GetCurrent();
269  }
270  catch( Dali::DaliException& e )
271  {
273  DALI_TEST_ASSERT( e, "stage && \"Stage doesn't exist\"", TEST_LOCATION );
274  asserted = true;
275  }
276 
277  DALI_TEST_CHECK( asserted );
278  END_TEST;
279 }
280 
282 {
283  TestApplication application;
284 
286 
288  END_TEST;
289 }
290 
292 {
294 
295  END_TEST;
296 }
297 
299 {
300  TestApplication application;
301  Stage stage = Stage::GetCurrent();
302 
303  Stage copyStage( stage );
304 
305  DALI_TEST_CHECK( copyStage );
306  DALI_TEST_CHECK( copyStage.GetRootLayer() == stage.GetRootLayer() );
307 
308  END_TEST;
309 }
310 
311 // Note: no negative test for UtcDaliStageCopyConstructor.
312 
314 {
315  TestApplication application;
316  const Stage stage = Stage::GetCurrent();
317 
318  Stage copyStage = stage;
319 
320  DALI_TEST_CHECK( copyStage );
321  DALI_TEST_CHECK( copyStage.GetRootLayer() == stage.GetRootLayer() );
322 
323  END_TEST;
324 }
325 
326 // Note: No negative test for UtcDaliStageAssignmentOperator.
327 
329 {
330  TestApplication application;
331 
332  Stage stage = Stage::GetCurrent();
333 
334  Actor actor = Actor::New();
335  DALI_TEST_CHECK( !actor.OnStage() );
336 
337  stage.Add( actor );
338  DALI_TEST_CHECK( actor.OnStage() );
339  END_TEST;
340 }
341 
343 {
344  TestApplication application;
345 
346  Stage stage = Stage::GetCurrent();
347  Actor actor;
348 
349  bool asserted = false;
350  try
351  {
352  stage.Add( actor );
353  }
354  catch( Dali::DaliException& e )
355  {
357  DALI_TEST_ASSERT( e, "actor && \"Actor handle is empty\"", TEST_LOCATION );
358  asserted = true;
359  }
360 
361  DALI_TEST_CHECK( asserted );
362 
363  END_TEST;
364 }
365 
367 {
368  TestApplication application;
369 
370  Stage stage = Stage::GetCurrent();
371 
372  Actor actor = Actor::New();
373  DALI_TEST_CHECK( !actor.OnStage() );
374 
375  stage.Add( actor );
376  DALI_TEST_CHECK( actor.OnStage() );
377 
378  stage.Remove(actor);
379  DALI_TEST_CHECK( !actor.OnStage() );
380  END_TEST;
381 }
382 
384 {
385  TestApplication application;
386 
387  Stage stage = Stage::GetCurrent();
388  Actor actor;
389 
390  bool asserted = false;
391  try
392  {
393  // Actor is not valid, confirm a removal attempt does assert.
394  stage.Remove( actor );
395  }
396  catch( Dali::DaliException& e )
397  {
399  DALI_TEST_ASSERT( e, "actor && \"Actor handle is empty\"", TEST_LOCATION );
400  asserted = true;
401  }
402 
403  DALI_TEST_CHECK( asserted );
404  END_TEST;
405 }
406 
408 {
409  TestApplication application;
410 
411  Stage stage = Stage::GetCurrent();
412  Actor actor = Actor::New();
413  DALI_TEST_CHECK( !actor.OnStage() );
414 
415  bool asserted = false;
416  try
417  {
418  // Actor is not on stage, confirm a removal attempt does not assert / segfault.
419  stage.Remove( actor );
420  }
421  catch( Dali::DaliException& e )
422  {
424  asserted = true;
425  }
426 
427  DALI_TEST_CHECK( !asserted );
428  END_TEST;
429 }
430 
432 {
433  TestApplication application;
434 
435  Stage stage = Stage::GetCurrent();
436 
437  // Initially we have a default layer
439 
440  // Check we cannot remove the root layer from the stage.
441  Layer layer = stage.GetRootLayer();
442  bool asserted = true;
443  try
444  {
445  stage.Remove( layer );
446  }
447  catch( Dali::DaliException& e )
448  {
450  DALI_TEST_ASSERT( e, "this != &child && \"Cannot remove actor from itself\"", TEST_LOCATION );
451  asserted = true;
452  }
453 
454  DALI_TEST_CHECK( asserted );
456  END_TEST;
457 }
458 
460 {
461  TestApplication application;
462 
463  Stage stage = Stage::GetCurrent();
464 
465  Vector2 size = stage.GetSize();
466 
469  END_TEST;
470 }
471 
473 {
474  TestApplication application;
475 
476  Stage stage;
477 
478  bool asserted = false;
479  Vector2 size;
480  try
481  {
482  size = stage.GetSize();
483  }
484  catch( Dali::DaliException& e )
485  {
487  DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
488  asserted = true;
489  }
490 
491  DALI_TEST_CHECK( asserted );
492  END_TEST;
493 }
494 
496 {
497  TestApplication application; // Initializes core DPI to default values
498 
499  Stage stage = Stage::GetCurrent();
500 
501  // Test the default DPI.
502  Vector2 dpi = stage.GetDpi();
505  END_TEST;
506 }
507 
509 {
510  TestApplication application; // Initializes core DPI to default values
511 
512  // Test that setting core DPI explicitly also sets up the Stage's DPI.
513  application.GetCore().SetDpi( 200, 180 );
514 
515  Stage stage = Stage::GetCurrent();
516  Vector2 dpi = stage.GetDpi();
517  DALI_TEST_EQUALS( dpi.x, 200.0f, TEST_LOCATION );
518  DALI_TEST_EQUALS( dpi.y, 180.0f, TEST_LOCATION );
519  END_TEST;
520 }
521 
523 {
524  TestApplication application( 480, 800, 72.0f, 120.0f ); // Initializes core DPI with specific values
525 
526  Stage stage = Stage::GetCurrent();
527 
528  // Test that setting core DPI explicitly also sets up the Stage's DPI.
529  Vector2 dpi = stage.GetDpi();
530  DALI_TEST_EQUALS( dpi.x, 72.0f, TEST_LOCATION );
531  DALI_TEST_EQUALS( dpi.y, 120.0f, TEST_LOCATION) ;
532  END_TEST;
533 }
534 
535 /*
536  * This is not a true negative test, we are checking the DPI if it has not been set.
537  * A test for setting negative DPI values would be part of the application core utc tests.
538  */
540 {
541  TestApplication application; // Initializes core DPI to default values
542 
543  Stage stage = Stage::GetCurrent();
544  Vector2 dpi = stage.GetDpi();
545 
546  DALI_TEST_EQUALS( dpi.x, 220.0f, TEST_LOCATION );
547  DALI_TEST_EQUALS( dpi.y, 217.0f, TEST_LOCATION );
548  END_TEST;
549 }
550 
552 {
553  TestApplication application;
554 
555  Stage stage = Stage::GetCurrent();
556 
557  // Initially we have a default layer
559 
560  Layer layer = Layer::New();
561  stage.Add( layer );
562 
564  END_TEST;
565 }
566 
567 /*
568  * Not a true negative test, but confirms layer count is not affected by an invalid removal.
569  */
571 {
572  TestApplication application;
573 
574  Stage stage = Stage::GetCurrent();
575 
576  // Initially we have a default layer
578 
579  Layer layer = Layer::New();
580  stage.Remove( layer );
581 
582  // Still have 1 layer.
584  END_TEST;
585 }
586 
588 {
589  TestApplication application;
590 
591  Stage stage = Stage::GetCurrent();
592 
593  Layer rootLayer = stage.GetLayer( 0 );
594  DALI_TEST_CHECK( rootLayer );
595 
596  Layer layer = Layer::New();
597  stage.Add( layer );
598 
599  Layer sameLayer = stage.GetLayer( 1 );
600  DALI_TEST_CHECK( layer == sameLayer );
601  END_TEST;
602 }
603 
605 {
606  TestApplication application;
607 
608  Stage stage = Stage::GetCurrent();
609 
610  bool asserted = false;
611  try
612  {
613  // Try to get a layer that doesn't exist (note: 0 is the root layer).
614  Layer layer = stage.GetLayer( 1 );
615  }
616  catch( Dali::DaliException& e )
617  {
619  DALI_TEST_ASSERT( e, "depth < mLayers.size()", TEST_LOCATION );
620  asserted = true;
621  }
622 
623  DALI_TEST_CHECK( asserted );
624  END_TEST;
625 }
626 
628 {
629  TestApplication application;
630 
631  Stage stage = Stage::GetCurrent();
632 
633  Layer layer = stage.GetLayer( 0 );
634  DALI_TEST_CHECK( layer );
635 
636  // Check that GetRootLayer() correctly retreived layer 0.
637  DALI_TEST_CHECK( stage.GetRootLayer() == layer );
638 
639  END_TEST;
640 }
641 
643 {
644  TestApplication application;
645 
646  Stage stage = Stage::GetCurrent();
647 
648  Layer rootLayer = stage.GetLayer( 0 );
649  DALI_TEST_CHECK( rootLayer );
650  DALI_TEST_CHECK( stage.GetRootLayer() == rootLayer );
651 
652  // Create a new layer and attempt to lower it below the root layer.
653  Layer layer = Layer::New();
654  stage.Add( layer );
655  layer.LowerToBottom();
656 
657  // Check that GetRootLayer still retrieves the same original layer.
658  DALI_TEST_CHECK( stage.GetRootLayer() == rootLayer );
659 
660  // Check modifying the root layer is also blocked.
661  rootLayer.RaiseToTop();
662  DALI_TEST_CHECK( stage.GetRootLayer() == rootLayer );
663 
664  END_TEST;
665 }
666 
668 {
669  TestApplication application;
670 
671  Stage stage = Stage::GetCurrent();
672 
673  Vector4 testColor( 0.1f, 0.2f, 0.3f, 1.0f );
674  stage.SetBackgroundColor( testColor );
675 
676  DALI_TEST_EQUALS( testColor, stage.GetBackgroundColor(), TEST_LOCATION );
677  END_TEST;
678 }
679 
680 // Note: No negative test for UtcDaliStageSetBackgroundColor as we do not wish to implement
681 // range checking for colors due to speed. Colors are clamped with glclampf within GL anyway.
682 
684 {
685  TestApplication application;
686 
687  Stage stage = Stage::GetCurrent();
688 
690  END_TEST;
691 }
692 
693 // Note: No negative test for UtcDaliStageGetBackgroundColor as this is covered by UtcDaliStageSetBackgroundColorN.
694 
696 {
697  TestApplication application;
698 
699  Stage stage = Stage::GetCurrent();
700 
701  // Run core until it wants to sleep
702  bool keepUpdating( true );
703  while ( keepUpdating )
704  {
705  application.SendNotification();
706  keepUpdating = application.Render( 1000.0f /*1 second*/ );
707  }
708 
709  // Force rendering for the next 5 seconds
710  stage.KeepRendering( 5.0f );
711 
712  application.SendNotification();
713 
714  // Test that core wants to sleep after 10 seconds
715  keepUpdating = application.Render( 1000.0f /*1 second*/ );
716  DALI_TEST_CHECK( keepUpdating );
717  keepUpdating = application.Render( 1000.0f /*2 seconds*/ );
718  DALI_TEST_CHECK( keepUpdating );
719  keepUpdating = application.Render( 1000.0f /*3 seconds*/ );
720  DALI_TEST_CHECK( keepUpdating );
721  keepUpdating = application.Render( 1000.0f /*4 seconds*/ );
722  DALI_TEST_CHECK( keepUpdating );
723  keepUpdating = application.Render( 1000.0f /*5 seconds*/ );
724  DALI_TEST_CHECK( !keepUpdating );
725  END_TEST;
726 }
727 
729 {
730  TestApplication application;
731 
732  Stage stage = Stage::GetCurrent();
733 
734  // Run core until it wants to sleep
735  bool keepUpdating( true );
736  while ( keepUpdating )
737  {
738  application.SendNotification();
739  keepUpdating = application.Render( 1000.0f /*1 second*/ );
740  }
741 
742  // Force rendering for the next 5 seconds
743  stage.KeepRendering( -1.0f );
744 
745  application.SendNotification();
746 
747  // Test that core wants to sleep after 10 seconds
748  keepUpdating = application.Render( 1000.0f /*1 second*/ );
749  DALI_TEST_CHECK( !keepUpdating );
750 
751  END_TEST;
752 }
753 
755 {
756  TestApplication application;
757  Stage stage = Stage::GetCurrent();
758 
759  bool eventProcessingFinished = false;
760  EventProcessingFinishedFunctor functor( eventProcessingFinished );
761  stage.EventProcessingFinishedSignal().Connect( &application, functor );
762 
763  Actor actor( Actor::New() );
764  stage.Add( actor );
765 
766  application.SendNotification();
767  application.Render();
768 
769  DALI_TEST_CHECK( eventProcessingFinished );
770 
771  END_TEST;
772 }
773 
775 {
776  TestApplication application;
777  Stage stage = Stage::GetCurrent();
778 
779  bool eventProcessingFinished = false;
780  EventProcessingFinishedFunctor functor( eventProcessingFinished );
781  stage.EventProcessingFinishedSignal().Connect( &application, functor );
782 
783  Actor actor( Actor::New() );
784  stage.Add( actor );
785 
786  // Do not complete event processing and confirm the signal has not been emitted.
787  DALI_TEST_CHECK( !eventProcessingFinished );
788 
789  END_TEST;
790 }
791 
793 {
794  TestApplication application;
795  Stage stage = Stage::GetCurrent();
796 
797  KeyEventSignalData data;
798  KeyEventReceivedFunctor functor( data );
799  stage.KeyEventSignal().Connect( &application, functor );
800 
801  Integration::KeyEvent event( "i", "i", 0, 0, 0, Integration::KeyEvent::Down );
802  application.ProcessEvent( event );
803 
804  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
805  DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier );
806  DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName );
807  DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed );
808  DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
809 
810  data.Reset();
811 
812  Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up );
813  application.ProcessEvent( event2 );
814 
815  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
816  DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier );
817  DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName );
818  DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed );
819  DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
820 
821  data.Reset();
822 
823  Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down );
824  application.ProcessEvent( event3 );
825 
826  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
827  DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier );
828  DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName );
829  DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed );
830  DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
831 
832  data.Reset();
833 
834  Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up );
835  application.ProcessEvent( event4 );
836 
837  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
838  DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier );
839  DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName );
840  DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed );
841  DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
842  END_TEST;
843 }
844 
846 {
847  TestApplication application;
848  Stage stage = Stage::GetCurrent();
849 
850  KeyEventSignalData data;
851  KeyEventReceivedFunctor functor( data );
852  stage.KeyEventSignal().Connect( &application, functor );
853 
854  // Check that a non-pressed key events data is not modified.
855  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
856 
857  END_TEST;
858 }
859 
861 {
862  TestApplication application;
863  Stage stage = Stage::GetCurrent();
864 
865  TouchedSignalData data;
866  TouchedFunctor functor( data );
867  stage.TouchedSignal().Connect( &application, functor );
868 
869  // Render and notify.
870  application.SendNotification();
871  application.Render();
872 
873  // Basic test: No actors, single touch (down then up).
874  {
875  Integration::TouchEvent touchEvent;
876  touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
877  application.ProcessEvent( touchEvent );
878 
879  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
880  DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
881  DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
882  data.Reset();
883 
884  touchEvent.points[0].state = TouchPoint::Up;
885  application.ProcessEvent( touchEvent );
886 
887  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
888  DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
889  DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
890  data.Reset();
891  }
892 
893  // Add an actor to the scene.
894  Actor actor = Actor::New();
895  actor.SetSize( 100.0f, 100.0f );
898  actor.TouchedSignal().Connect( &DummyTouchCallback );
899  stage.Add( actor );
900 
901  // Render and notify.
902  application.SendNotification();
903  application.Render();
904 
905  // Actor on scene, single touch, down in actor, motion, then up outside actor.
906  {
907  Integration::TouchEvent touchEvent;
908  touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
909  application.ProcessEvent( touchEvent );
910 
911  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
912  DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
913  DALI_TEST_CHECK( data.receivedTouchEvent.points[0].hitActor == actor );
914  data.Reset();
915 
916  touchEvent.points[0].state = TouchPoint::Motion;
917  touchEvent.points[0].screen.x = 150.0f; // Some motion
918  application.ProcessEvent( touchEvent );
919 
920  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
921  data.Reset();
922 
923  touchEvent.points[0].state = TouchPoint::Up;
924  application.ProcessEvent( touchEvent );
925 
926  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
927  DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
928  DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
929  data.Reset();
930  }
931 
932  // Multiple touch. Should only receive a touch on first down and last up.
933  {
934  Integration::TouchEvent touchEvent;
935 
936  // 1st point
937  touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
938  application.ProcessEvent( touchEvent );
939  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
940  DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
941  data.Reset();
942 
943  // 2nd point
944  touchEvent.points[0].state = TouchPoint::Stationary;
945  touchEvent.points.push_back( TouchPoint( 1, TouchPoint::Down, 50.0f, 50.0f ) );
946  application.ProcessEvent( touchEvent );
947  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
948  DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 0u, TEST_LOCATION );
949  data.Reset();
950 
951  // Primary point is up
952  touchEvent.points[0].state = TouchPoint::Up;
953  touchEvent.points[1].state = TouchPoint::Stationary;
954  application.ProcessEvent( touchEvent );
955  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
956  DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 0u, TEST_LOCATION );
957  data.Reset();
958 
959  // Remove 1st point now, 2nd point is now in motion
960  touchEvent.points.erase( touchEvent.points.begin() );
961  touchEvent.points[0].state = TouchPoint::Motion;
962  touchEvent.points[0].screen.x = 150.0f;
963  application.ProcessEvent( touchEvent );
964  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
965  DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 0u, TEST_LOCATION );
966  data.Reset();
967 
968  // Final point Up
969  touchEvent.points[0].state = TouchPoint::Up;
970  application.ProcessEvent( touchEvent );
971  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
972  DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
973  data.Reset();
974  }
975  END_TEST;
976 }
977 
979 {
980  TestApplication application;
981  Stage stage = Stage::GetCurrent();
982 
983  TouchedSignalData data;
984  TouchedFunctor functor( data );
985  stage.TouchedSignal().Connect( &application, functor );
986 
987  // Render and notify.
988  application.SendNotification();
989  application.Render();
990 
991  // Confirm functor not called before there has been any touch event.
992  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
993 
994  // No actors, single touch, down, motion then up.
995  {
996  Integration::TouchEvent touchEvent;
997  touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
998  application.ProcessEvent( touchEvent );
999 
1000  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1001  DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
1002  DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
1003  data.Reset();
1004 
1005  // Confirm there is no signal when the touchpoint is only moved.
1006  touchEvent.points[0].state = TouchPoint::Motion;
1007  touchEvent.points[0].screen.x = 1200.0f; // Some motion
1008  application.ProcessEvent( touchEvent );
1009 
1010  DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
1011  data.Reset();
1012 
1013  // Confirm a following up event generates a signal.
1014  touchEvent.points[0].state = TouchPoint::Up;
1015  application.ProcessEvent( touchEvent );
1016 
1017  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1018  DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
1019  DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
1020  data.Reset();
1021  }
1022 
1023  // Add an actor to the scene.
1024  Actor actor = Actor::New();
1025  actor.SetSize( 100.0f, 100.0f );
1028  actor.TouchedSignal().Connect( &DummyTouchCallback );
1029  stage.Add( actor );
1030 
1031  // Render and notify.
1032  application.SendNotification();
1033  application.Render();
1034 
1035  // Actor on scene. Interrupted before down and interrupted after down.
1036  {
1037  Integration::TouchEvent touchEvent;
1038  touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Interrupted, 10.0f, 10.0f ) );
1039  application.ProcessEvent( touchEvent );
1040 
1041  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1042  DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
1043  DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
1044  DALI_TEST_CHECK( data.receivedTouchEvent.points[0].state == TouchPoint::Interrupted );
1045  data.Reset();
1046 
1047  touchEvent.points[0].state = TouchPoint::Down;
1048  application.ProcessEvent( touchEvent );
1049 
1050  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1051  DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
1052  DALI_TEST_CHECK( data.receivedTouchEvent.points[0].hitActor == actor );
1053  DALI_TEST_CHECK( data.receivedTouchEvent.points[0].state == TouchPoint::Down );
1054  data.Reset();
1055 
1056  touchEvent.points[0].state = TouchPoint::Interrupted;
1057  application.ProcessEvent( touchEvent );
1058 
1059  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1060  DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
1061  DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
1062  DALI_TEST_CHECK( data.receivedTouchEvent.points[0].state == TouchPoint::Interrupted );
1063 
1064  DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
1065 
1066  // Check that getting info about a non-existent point causes an assert.
1067  bool asserted = false;
1068  try
1069  {
1070  data.receivedTouchEvent.GetPoint( 1 );
1071  }
1072  catch( Dali::DaliException& e )
1073  {
1075  DALI_TEST_ASSERT( e, "point < points.size() && \"No point at index\"", TEST_LOCATION );
1076  asserted = true;
1077  }
1078  DALI_TEST_CHECK( asserted );
1079 
1080  data.Reset();
1081  }
1082 
1083  END_TEST;
1084 }
1085 
1087 {
1088  TestApplication application;
1089  Stage stage = Stage::GetCurrent();
1090 
1091  WheelEventSignalData data;
1092  WheelEventReceivedFunctor functor( data );
1093  stage.WheelEventSignal().Connect( &application, functor );
1094 
1095  Integration::WheelEvent event( Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2( 0.0f, 0.0f ), 1, 1000u );
1096  application.ProcessEvent( event );
1097 
1098  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1099  DALI_TEST_CHECK( static_cast< WheelEvent::Type >(event.type) == data.receivedWheelEvent.type );
1100  DALI_TEST_CHECK( event.direction == data.receivedWheelEvent.direction );
1101  DALI_TEST_CHECK( event.modifiers == data.receivedWheelEvent.modifiers );
1102  DALI_TEST_CHECK( event.point == data.receivedWheelEvent.point );
1103  DALI_TEST_CHECK( event.z == data.receivedWheelEvent.z );
1104  DALI_TEST_CHECK( event.timeStamp == data.receivedWheelEvent.timeStamp );
1105 
1106  data.Reset();
1107 
1108  Integration::WheelEvent event2( Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2( 0.0f, 0.0f ), -1, 1000u );
1109  application.ProcessEvent( event2 );
1110 
1111  DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1112  DALI_TEST_CHECK( static_cast< WheelEvent::Type >(event2.type) == data.receivedWheelEvent.type );
1113  DALI_TEST_CHECK( event2.direction == data.receivedWheelEvent.direction );
1114  DALI_TEST_CHECK( event2.modifiers == data.receivedWheelEvent.modifiers );
1115  DALI_TEST_CHECK( event2.point == data.receivedWheelEvent.point );
1116  DALI_TEST_CHECK( event2.z == data.receivedWheelEvent.z );
1117  DALI_TEST_CHECK( event2.timeStamp == data.receivedWheelEvent.timeStamp );
1118  END_TEST;
1119 }
1120 
1122 {
1123  TestApplication app;
1124  Stage stage = Stage::GetCurrent();
1125 
1126  bool contextLost = false;
1127  ContextStatusFunctor contextLostFunctor( contextLost );
1128  stage.ContextLostSignal().Connect( &app, contextLostFunctor );
1129 
1131  notifier->NotifyContextLost();
1132  DALI_TEST_EQUALS( contextLost, true, TEST_LOCATION );
1133 
1134  END_TEST;
1135 }
1136 
1138 {
1139  TestApplication app;
1140  Stage stage;
1141 
1142  // Check that connecting to the signal with a bad stage instance causes an assert.
1143  bool asserted = false;
1144  bool contextLost = false;
1145  ContextStatusFunctor contextLostFunctor( contextLost );
1146  try
1147  {
1148  stage.ContextLostSignal().Connect( &app, contextLostFunctor );
1149  }
1150  catch( Dali::DaliException& e )
1151  {
1153  DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
1154  asserted = true;
1155  }
1156  DALI_TEST_CHECK( asserted );
1157 
1158  END_TEST;
1159 }
1160 
1162 {
1163  TestApplication app;
1164  Stage stage = Stage::GetCurrent();
1165 
1166  bool contextRegained = false;
1167  ContextStatusFunctor contextRegainedFunctor( contextRegained );
1168  stage.ContextRegainedSignal().Connect( &app, contextRegainedFunctor );
1169 
1171  notifier->NotifyContextLost();
1172  notifier->NotifyContextRegained();
1173  DALI_TEST_EQUALS( contextRegained, true, TEST_LOCATION );
1174 
1175  END_TEST;
1176 }
1177 
1179 {
1180  TestApplication app;
1181  Stage stage;
1182 
1183  // Check that connecting to the signal with a bad stage instance causes an assert.
1184  bool asserted = false;
1185  bool contextRegained = false;
1186  ContextStatusFunctor contextRegainedFunctor( contextRegained );
1187  try
1188  {
1189  stage.ContextRegainedSignal().Connect( &app, contextRegainedFunctor );
1190  }
1191  catch( Dali::DaliException& e )
1192  {
1194  DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
1195  asserted = true;
1196  }
1197  DALI_TEST_CHECK( asserted );
1198 
1199  END_TEST;
1200 }
1201 
1203 {
1204  TestApplication app;
1205  Stage stage = Stage::GetCurrent();
1206 
1207  bool signalCalled = false;
1208  SceneCreatedStatusFunctor sceneCreatedFunctor( signalCalled );
1209  stage.SceneCreatedSignal().Connect( &app, sceneCreatedFunctor );
1210 
1211  Integration::Core& core = app.GetCore();
1212  core.SceneCreated();
1213  DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
1214 
1215  END_TEST;
1216 }
1217 
1219 {
1220  TestApplication app;
1221  Stage stage;
1222 
1223  // Check that connecting to the signal with a bad stage instance causes an assert.
1224  bool asserted = false;
1225  bool signalCalled = false;
1226  SceneCreatedStatusFunctor sceneCreatedFunctor( signalCalled );
1227  try
1228  {
1229  stage.SceneCreatedSignal().Connect( &app, sceneCreatedFunctor );
1230  }
1231  catch( Dali::DaliException& e )
1232  {
1234  DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
1235  asserted = true;
1236  }
1237  DALI_TEST_CHECK( asserted );
1238 
1239  END_TEST;
1240 }
1241 
1243 {
1244  TestApplication app;
1245  Stage stage = Stage::GetCurrent();
1246 
1247  // Check we get a valid instance.
1248  const RenderTaskList& tasks = stage.GetRenderTaskList();
1249 
1250  // There should be 1 task by default.
1252 
1253  // RenderTaskList has it's own UTC tests.
1254  // But we can confirm that GetRenderTaskList in Stage retrieves the same RenderTaskList each time.
1255  RenderTask newTask = stage.GetRenderTaskList().CreateTask();
1256 
1257  DALI_TEST_EQUALS( stage.GetRenderTaskList().GetTask( 1 ), newTask, TEST_LOCATION );
1258 
1259  END_TEST;
1260 }
1261 
1263 {
1264  TestApplication app;
1265  Stage stage;
1266 
1267  // Check that getting the render task list with a bad stage instance causes an assert.
1268  bool asserted = false;
1269  try
1270  {
1271  stage.GetRenderTaskList();
1272  }
1273  catch( Dali::DaliException& e )
1274  {
1276  DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
1277  asserted = true;
1278  }
1279  DALI_TEST_CHECK( asserted );
1280 
1281  END_TEST;
1282 }
1283 
1285 {
1286  TestApplication app;
1287  Stage stage = Stage::GetCurrent();
1288 
1289  ObjectRegistry objectRegistry = stage.GetObjectRegistry();
1290 
1291  // Object registry tests are covered in their own module.
1292  // However we want a basic test to confirm the returned registry is valid and works.
1293  bool verified = false;
1294  ActorCreatedFunctor test( verified );
1295  objectRegistry.ObjectCreatedSignal().Connect( &app, test );
1296 
1297  Actor actor = Actor::New();
1298  DALI_TEST_CHECK( test.mSignalVerified );
1299 
1300  END_TEST;
1301 }
1302 
1304 {
1305  TestApplication app;
1306  Stage stage;
1307 
1308  // Check that getting the object registry with a bad stage instance DOES NOT cause an assert.
1309  // This is because GetCurrent() is used, always creating a stage if one does not exist.
1310  bool asserted = false;
1311  try
1312  {
1313  stage.GetObjectRegistry();
1314  }
1315  catch( Dali::DaliException& e )
1316  {
1318  asserted = true;
1319  }
1320  DALI_TEST_CHECK( !asserted );
1321 
1322  END_TEST;
1323 }
Dali Docs Home
Read more about Dali