automated-tests/src/dali/utc-Dali-Scene.cpp

   1 /*
   2  * Copyright (c) 2022 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 <dali-test-suite-utils.h>
  19 #include <dali/devel-api/common/stage.h>
  20 #include <dali/integration-api/events/key-event-integ.h>
  21 #include <dali/integration-api/events/touch-event-integ.h>
  22 #include <dali/integration-api/events/wheel-event-integ.h>
  23 #include <dali/integration-api/scene.h>
  24 #include <dali/public-api/events/key-event.h>
  25 #include <mesh-builder.h>
  26 #include <stdlib.h>
  27
  28 #include <iostream>
  29
  30 // Internal headers are allowed here
  31
  32 namespace
  33 {
  34 const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
  35
  36 // Functor for EventProcessingFinished signal
  37 struct EventProcessingFinishedFunctor
  38 {
  39   /**
  40    * @param[in] eventProcessingFinished reference to a boolean variable used to check if signal has been called.
  41    */
  42   EventProcessingFinishedFunctor(bool& eventProcessingFinished)
  43   : mEventProcessingFinished(eventProcessingFinished)
  44   {
  45   }
  46
  47   void operator()()
  48   {
  49     mEventProcessingFinished = true;
  50   }
  51
  52   bool& mEventProcessingFinished;
  53 };
  54
  55 // Stores data that is populated in the key-event callback and will be read by the TET cases
  56 struct KeyEventSignalData
  57 {
  58   KeyEventSignalData()
  59   : functorCalled(false)
  60   {
  61   }
  62
  63   void Reset()
  64   {
  65     functorCalled = false;
  66
  67     receivedKeyEvent.Reset();
  68   }
  69
  70   bool     functorCalled;
  71   KeyEvent receivedKeyEvent;
  72 };
  73
  74 // Functor that sets the data when called
  75 struct KeyEventReceivedFunctor
  76 {
  77   KeyEventReceivedFunctor(KeyEventSignalData& data)
  78   : signalData(data)
  79   {
  80   }
  81
  82   bool operator()(const KeyEvent& keyEvent)
  83   {
  84     signalData.functorCalled    = true;
  85     signalData.receivedKeyEvent = keyEvent;
  86
  87     return true;
  88   }
  89
  90   KeyEventSignalData& signalData;
  91 };
  92
  93 // Stores data that is populated in the touched signal callback and will be read by the TET cases
  94 struct TouchedSignalData
  95 {
  96   TouchedSignalData()
  97   : functorCalled(false),
  98     createNewScene(false),
  99     newSceneCreated(false)
 100   {
 101   }
 102
 103   void Reset()
 104   {
 105     functorCalled   = false;
 106     createNewScene  = false;
 107     newSceneCreated = false;
 108     receivedTouchEvent.Reset();
 109   }
 110
 111   bool       functorCalled;
 112   bool       createNewScene;
 113   bool       newSceneCreated;
 114   TouchEvent receivedTouchEvent;
 115 };
 116
 117 // Functor that sets the data when touched signal is received
 118 struct TouchFunctor
 119 {
 120   TouchFunctor(TouchedSignalData& data)
 121   : signalData(data)
 122   {
 123   }
 124
 125   void operator()(const TouchEvent& touch)
 126   {
 127     signalData.functorCalled      = true;
 128     signalData.receivedTouchEvent = touch;
 129
 130     if(signalData.createNewScene)
 131     {
 132       Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
 133       DALI_TEST_CHECK(scene);
 134
 135       signalData.newSceneCreated = true;
 136     }
 137   }
 138
 139   void operator()()
 140   {
 141     signalData.functorCalled = true;
 142   }
 143
 144   TouchedSignalData& signalData;
 145 };
 146
 147 // Stores data that is populated in the wheel-event callback and will be read by the TET cases
 148 struct WheelEventSignalData
 149 {
 150   WheelEventSignalData()
 151   : functorCalled(false)
 152   {
 153   }
 154
 155   void Reset()
 156   {
 157     functorCalled = false;
 158   }
 159
 160   bool       functorCalled;
 161   WheelEvent receivedWheelEvent;
 162 };
 163
 164 // Functor that sets the data when wheel-event signal is received
 165 struct WheelEventReceivedFunctor
 166 {
 167   WheelEventReceivedFunctor(WheelEventSignalData& data)
 168   : signalData(data)
 169   {
 170   }
 171
 172   bool operator()(const WheelEvent& wheelEvent)
 173   {
 174     signalData.functorCalled      = true;
 175     signalData.receivedWheelEvent = wheelEvent;
 176
 177     return true;
 178   }
 179
 180   WheelEventSignalData& signalData;
 181 };
 182
 183 // Stores data that is populated in the KeyEventGeneratedSignal callback and will be read by the TET cases
 184 struct KeyEventGeneratedSignalData
 185 {
 186   KeyEventGeneratedSignalData()
 187   : functorCalled(false)
 188   {
 189   }
 190
 191   void Reset()
 192   {
 193     functorCalled = false;
 194
 195     receivedKeyEvent.Reset();
 196   }
 197
 198   bool     functorCalled;
 199   KeyEvent receivedKeyEvent;
 200 };
 201
 202 // Functor that sets the data when called
 203 struct KeyEventGeneratedReceivedFunctor
 204 {
 205   KeyEventGeneratedReceivedFunctor(KeyEventGeneratedSignalData& data)
 206   : signalData(data)
 207   {
 208   }
 209
 210   bool operator()(const KeyEvent& keyEvent)
 211   {
 212     signalData.functorCalled    = true;
 213     signalData.receivedKeyEvent = keyEvent;
 214
 215     return true;
 216   }
 217
 218   bool operator()()
 219   {
 220     signalData.functorCalled = true;
 221     return true;
 222   }
 223
 224   KeyEventGeneratedSignalData& signalData;
 225 };
 226
 227 // Stores data that is populated in the WheelEventGeneratedSignal callback and will be read by the TET cases
 228 struct WheelEventGeneratedSignalData
 229 {
 230   WheelEventGeneratedSignalData()
 231   : functorCalled(false)
 232   {
 233   }
 234
 235   void Reset()
 236   {
 237     functorCalled = false;
 238
 239     receivedWheelEvent.Reset();
 240   }
 241
 242   bool       functorCalled;
 243   WheelEvent receivedWheelEvent;
 244 };
 245
 246 // Functor that sets the data when called
 247 struct WheelEventGeneratedReceivedFunctor
 248 {
 249   WheelEventGeneratedReceivedFunctor(WheelEventGeneratedSignalData& data)
 250   : signalData(data)
 251   {
 252   }
 253
 254   bool operator()(const WheelEvent& wheelEvent)
 255   {
 256     signalData.functorCalled      = true;
 257     signalData.receivedWheelEvent = wheelEvent;
 258
 259     return true;
 260   }
 261
 262   bool operator()()
 263   {
 264     signalData.functorCalled = true;
 265     return true;
 266   }
 267
 268   WheelEventGeneratedSignalData& signalData;
 269 };
 270
 271 void GenerateTouch(TestApplication& application, PointState::Type state, const Vector2& screenPosition)
 272 {
 273   Integration::TouchEvent touchEvent;
 274   Integration::Point      point;
 275   point.SetState(state);
 276   point.SetScreenPosition(screenPosition);
 277   touchEvent.points.push_back(point);
 278   application.ProcessEvent(touchEvent);
 279 }
 280
 281 bool DummyTouchCallback(Actor actor, const TouchEvent& touch)
 282 {
 283   return true;
 284 }
 285
 286 void FrameCallback(int frameId)
 287 {
 288 }
 289
 290 } // unnamed namespace
 291
 292 int UtcDaliSceneAdd(void)
 293 {
 294   TestApplication application;
 295   tet_infoline("Testing Dali::Integration::Scene::Add");
 296
 297   Dali::Integration::Scene scene = application.GetScene();
 298
 299   Actor actor = Actor::New();
 300   DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 301
 302   scene.Add(actor);
 303   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 304
 305   END_TEST;
 306 }
 307
 308 int UtcDaliSceneRemove(void)
 309 {
 310   TestApplication application;
 311   tet_infoline("Testing Dali::Integration::Scene::Remove");
 312
 313   Dali::Integration::Scene scene = application.GetScene();
 314
 315   Actor actor = Actor::New();
 316   DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 317
 318   scene.Add(actor);
 319   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 320
 321   scene.Remove(actor);
 322   DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 323
 324   END_TEST;
 325 }
 326
 327 int UtcDaliSceneGetSize(void)
 328 {
 329   TestApplication application;
 330   tet_infoline("Testing Dali::Integration::Scene::GetSize");
 331
 332   Dali::Integration::Scene scene = application.GetScene();
 333   Size                     size  = scene.GetSize();
 334   DALI_TEST_EQUALS(TestApplication::DEFAULT_SURFACE_WIDTH, size.width, TEST_LOCATION);
 335   DALI_TEST_EQUALS(TestApplication::DEFAULT_SURFACE_HEIGHT, size.height, TEST_LOCATION);
 336
 337   END_TEST;
 338 }
 339
 340 int UtcDaliSceneGetDpi(void)
 341 {
 342   TestApplication application; // Initializes core DPI to default values
 343
 344   // Test that setting core DPI explicitly also sets up the scene's DPI.
 345   Dali::Integration::Scene scene = application.GetScene();
 346   scene.SetDpi(Vector2(200.0f, 180.0f));
 347   Vector2 dpi = scene.GetDpi();
 348   DALI_TEST_EQUALS(dpi.x, 200.0f, TEST_LOCATION);
 349   DALI_TEST_EQUALS(dpi.y, 180.0f, TEST_LOCATION);
 350   END_TEST;
 351 }
 352
 353 int UtcDaliSceneGetRenderTaskList(void)
 354 {
 355   TestApplication application;
 356   tet_infoline("Testing Dali::Integration::Scene::GetRenderTaskList");
 357
 358   Dali::Integration::Scene scene = application.GetScene();
 359
 360   // Check we get a valid instance.
 361   const RenderTaskList& tasks = scene.GetRenderTaskList();
 362
 363   // There should be 1 task by default.
 364   DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION);
 365
 366   // RenderTaskList has it's own UTC tests.
 367   // But we can confirm that GetRenderTaskList in Stage retrieves the same RenderTaskList each time.
 368   RenderTask newTask = scene.GetRenderTaskList().CreateTask();
 369
 370   DALI_TEST_EQUALS(scene.GetRenderTaskList().GetTask(1), newTask, TEST_LOCATION);
 371
 372   END_TEST;
 373 }
 374
 375 int UtcDaliSceneGetRootLayer(void)
 376 {
 377   TestApplication application;
 378   tet_infoline("Testing Dali::Integration::Scene::GetRootLayer");
 379
 380   Dali::Integration::Scene scene = application.GetScene();
 381   Layer                    layer = scene.GetLayer(0);
 382   DALI_TEST_CHECK(layer);
 383
 384   // Check that GetRootLayer() correctly retreived layer 0.
 385   DALI_TEST_CHECK(scene.GetRootLayer() == layer);
 386
 387   END_TEST;
 388 }
 389
 390 int UtcDaliSceneGetLayerCount(void)
 391 {
 392   TestApplication application;
 393   tet_infoline("Testing Dali::Integration::Scene::GetLayerCount");
 394
 395   Dali::Integration::Scene scene = application.GetScene();
 396   // Initially we have a default layer
 397   DALI_TEST_EQUALS(scene.GetLayerCount(), 1u, TEST_LOCATION);
 398
 399   Layer layer = Layer::New();
 400   scene.Add(layer);
 401
 402   DALI_TEST_EQUALS(scene.GetLayerCount(), 2u, TEST_LOCATION);
 403   END_TEST;
 404 }
 405
 406 int UtcDaliSceneGetLayer(void)
 407 {
 408   TestApplication application;
 409   tet_infoline("Testing Dali::Integration::Scene::GetLayer");
 410
 411   Dali::Integration::Scene scene = application.GetScene();
 412
 413   Layer rootLayer = scene.GetLayer(0);
 414   DALI_TEST_CHECK(rootLayer);
 415
 416   Layer layer = Layer::New();
 417   scene.Add(layer);
 418
 419   Layer sameLayer = scene.GetLayer(1);
 420   DALI_TEST_CHECK(layer == sameLayer);
 421
 422   END_TEST;
 423 }
 424
 425 int UtcDaliSceneGet(void)
 426 {
 427   TestApplication application;
 428   tet_infoline("Testing Dali::Integration::Scene::Get");
 429
 430   Dali::Integration::Scene scene = application.GetScene();
 431
 432   Actor parent = Actor::New();
 433   Actor child  = Actor::New();
 434
 435   parent.Add(child);
 436
 437   // Should be empty scene
 438   DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(parent));
 439   DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(child));
 440
 441   scene.Add(parent);
 442
 443   // Should return the valid scene
 444   DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(parent));
 445   DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(child));
 446
 447   parent.Unparent();
 448
 449   // Should be empty scene
 450   DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(parent));
 451   DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(child));
 452
 453   END_TEST;
 454 }
 455
 456 int UtcDaliSceneDiscard(void)
 457 {
 458   TestApplication application;
 459   tet_infoline("Testing Dali::Scene::Discard");
 460
 461   // Create a new Scene
 462   Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
 463   DALI_TEST_CHECK(scene);
 464
 465   // One reference of scene kept here and the other one kept in the Core
 466   DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 2);
 467
 468   // Render and notify.
 469   application.SendNotification();
 470   application.Render(0);
 471
 472   // Keep the reference of the root layer handle so it will still be alive after the scene is deleted
 473   Layer rootLayer = scene.GetRootLayer();
 474   DALI_TEST_CHECK(rootLayer);
 475   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 2);
 476
 477   // Request to discard the scene from the Core
 478   scene.Discard();
 479   DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 1);
 480
 481   // Reset the scene handle
 482   scene.Reset();
 483
 484   // Render and notify.
 485   application.SendNotification();
 486   application.Render(0);
 487
 488   // At this point, the scene should have been automatically deleted
 489   // To prove this, the ref count of the root layer handle should be decremented to 1
 490   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
 491
 492   // Delete the root layer handle
 493   rootLayer.Reset();
 494
 495   // Render and notify.
 496   application.SendNotification();
 497   application.Render(0);
 498
 499   END_TEST;
 500 }
 501
 502 int UtcDaliSceneCreateNewSceneDuringCoreEventProcessing(void)
 503 {
 504   TestApplication application;
 505
 506   Dali::Integration::Scene scene = application.GetScene();
 507
 508   TouchedSignalData data;
 509   data.createNewScene = true;
 510   TouchFunctor functor(data);
 511   scene.TouchedSignal().Connect(&application, functor);
 512
 513   // Render and notify.
 514   application.SendNotification();
 515   application.Render();
 516
 517   GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 518
 519   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 520   DALI_TEST_EQUALS(true, data.createNewScene, TEST_LOCATION);
 521   DALI_TEST_EQUALS(true, data.newSceneCreated, TEST_LOCATION);
 522   data.Reset();
 523
 524   END_TEST;
 525 }
 526
 527 int UtcDaliSceneRootLayerAndSceneAlignment(void)
 528 {
 529   TestApplication application;
 530
 531   // Create a Scene
 532   Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
 533   DALI_TEST_CHECK(scene);
 534
 535   // One reference of scene kept here and the other one kept in the Core
 536   DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 2);
 537
 538   // Add a renderable actor to the scene
 539   auto actor = CreateRenderableActor();
 540   scene.Add(actor);
 541
 542   // Render and notify.
 543   application.SendNotification();
 544   application.Render(0);
 545
 546   // Keep the reference of the root layer handle so it will still be alive after the scene is deleted
 547   Layer rootLayer = scene.GetRootLayer();
 548   DALI_TEST_CHECK(rootLayer);
 549   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 2);
 550
 551   // Request to discard the scene from the Core
 552   scene.Discard();
 553   DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 1);
 554
 555   // Reset the scene handle
 556   scene.Reset();
 557
 558   // Render and notify.
 559   application.SendNotification();
 560   application.Render(0);
 561
 562   // At this point, the scene should have been automatically deleted
 563   // To prove this, the ref count of the root layer handle should be decremented to 1
 564   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
 565
 566   // Create a new Scene while the root layer of the deleted scene is still alive
 567   Dali::Integration::Scene newScene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
 568   DALI_TEST_CHECK(newScene);
 569
 570   // Render and notify.
 571   application.SendNotification();
 572   application.Render(0);
 573
 574   // At this point, we have only one scene but two root layers
 575   // The root layer of the deleted scene is still alive
 576   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
 577
 578   // Delete the root layer of the deleted scene
 579   rootLayer.Reset();
 580
 581   // Render and notify.
 582   application.SendNotification();
 583   application.Render(0);
 584
 585   END_TEST;
 586 }
 587
 588 int UtcDaliSceneEventProcessingFinishedP(void)
 589 {
 590   TestApplication          application;
 591   Dali::Integration::Scene scene = application.GetScene();
 592
 593   bool                           eventProcessingFinished = false;
 594   EventProcessingFinishedFunctor functor(eventProcessingFinished);
 595   scene.EventProcessingFinishedSignal().Connect(&application, functor);
 596
 597   Actor actor(Actor::New());
 598   scene.Add(actor);
 599
 600   application.SendNotification();
 601   application.Render();
 602
 603   DALI_TEST_CHECK(eventProcessingFinished);
 604
 605   END_TEST;
 606 }
 607
 608 int UtcDaliSceneEventProcessingFinishedN(void)
 609 {
 610   TestApplication          application;
 611   Dali::Integration::Scene scene = application.GetScene();
 612
 613   bool                           eventProcessingFinished = false;
 614   EventProcessingFinishedFunctor functor(eventProcessingFinished);
 615   scene.EventProcessingFinishedSignal().Connect(&application, functor);
 616
 617   Actor actor(Actor::New());
 618   scene.Add(actor);
 619
 620   // Do not complete event processing and confirm the signal has not been emitted.
 621   DALI_TEST_CHECK(!eventProcessingFinished);
 622
 623   END_TEST;
 624 }
 625
 626 int UtcDaliSceneSignalKeyEventP(void)
 627 {
 628   TestApplication          application;
 629   Dali::Integration::Scene scene = application.GetScene();
 630
 631   KeyEventSignalData      data;
 632   KeyEventReceivedFunctor functor(data);
 633   scene.KeyEventSignal().Connect(&application, functor);
 634
 635   Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 636   application.ProcessEvent(event);
 637
 638   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 639   DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
 640   DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
 641   DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
 642   DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
 643
 644   data.Reset();
 645
 646   Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 647   application.ProcessEvent(event2);
 648
 649   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 650   DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
 651   DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
 652   DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
 653   DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
 654
 655   data.Reset();
 656
 657   Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 658   application.ProcessEvent(event3);
 659
 660   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 661   DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
 662   DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
 663   DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
 664   DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
 665
 666   data.Reset();
 667
 668   Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 669   application.ProcessEvent(event4);
 670
 671   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 672   DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
 673   DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
 674   DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
 675   DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
 676   END_TEST;
 677 }
 678
 679 int UtcDaliSceneSignalKeyEventN(void)
 680 {
 681   TestApplication          application;
 682   Dali::Integration::Scene scene = application.GetScene();
 683
 684   KeyEventSignalData      data;
 685   KeyEventReceivedFunctor functor(data);
 686   scene.KeyEventSignal().Connect(&application, functor);
 687
 688   // Check that a non-pressed key events data is not modified.
 689   DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 690
 691   END_TEST;
 692 }
 693
 694 int UtcDaliSceneTouchedSignalP(void)
 695 {
 696   TestApplication          application;
 697   Dali::Integration::Scene scene = application.GetScene();
 698
 699   TouchedSignalData data;
 700   TouchFunctor      functor(data);
 701   scene.TouchedSignal().Connect(&application, functor);
 702
 703   // Render and notify.
 704   application.SendNotification();
 705   application.Render();
 706
 707   // Basic test: No actors, single touch (down then up).
 708   {
 709     GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 710
 711     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 712     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 713     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 714     data.Reset();
 715
 716     GenerateTouch(application, PointState::UP, Vector2(10.0f, 10.0f));
 717
 718     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 719     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 720     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 721     data.Reset();
 722   }
 723
 724   // Add an actor to the scene.
 725   Actor actor = Actor::New();
 726   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
 727   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 728   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 729   actor.TouchedSignal().Connect(&DummyTouchCallback);
 730   scene.Add(actor);
 731
 732   // Render and notify.
 733   application.SendNotification();
 734   application.Render();
 735
 736   // Actor on scene, single touch, down in actor, motion, then up outside actor.
 737   {
 738     GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 739
 740     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 741     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 742     DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0) == actor);
 743     data.Reset();
 744
 745     GenerateTouch(application, PointState::MOTION, Vector2(150.0f, 10.0f)); // Some motion
 746
 747     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 748     data.Reset();
 749
 750     GenerateTouch(application, PointState::UP, Vector2(150.0f, 10.0f)); // Some motion
 751
 752     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 753     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 754     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 755     data.Reset();
 756   }
 757
 758   // Multiple touch. Should only receive a touch on first down and last up.
 759   {
 760     Integration::TouchEvent touchEvent;
 761     Integration::Point      point;
 762
 763     // 1st point
 764     point.SetState(PointState::DOWN);
 765     point.SetScreenPosition(Vector2(10.0f, 10.0f));
 766     touchEvent.points.push_back(point);
 767     application.ProcessEvent(touchEvent);
 768     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 769     DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
 770     data.Reset();
 771
 772     // 2nd point
 773     touchEvent.points[0].SetState(PointState::STATIONARY);
 774     point.SetDeviceId(1);
 775     point.SetScreenPosition(Vector2(50.0f, 50.0f));
 776     touchEvent.points.push_back(point);
 777     application.ProcessEvent(touchEvent);
 778     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 779     data.Reset();
 780
 781     // Primary point is up
 782     touchEvent.points[0].SetState(PointState::UP);
 783     touchEvent.points[1].SetState(PointState::STATIONARY);
 784     application.ProcessEvent(touchEvent);
 785     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 786     data.Reset();
 787
 788     // Remove 1st point now, 2nd point is now in motion
 789     touchEvent.points.erase(touchEvent.points.begin());
 790     touchEvent.points[0].SetState(PointState::MOTION);
 791     touchEvent.points[0].SetScreenPosition(Vector2(150.0f, 50.0f));
 792     application.ProcessEvent(touchEvent);
 793     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 794     data.Reset();
 795
 796     // Final point Up
 797     touchEvent.points[0].SetState(PointState::UP);
 798     application.ProcessEvent(touchEvent);
 799     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 800     DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
 801     data.Reset();
 802   }
 803   END_TEST;
 804 }
 805
 806 int UtcDaliSceneTouchedSignalN(void)
 807 {
 808   TestApplication          application;
 809   Dali::Integration::Scene scene = application.GetScene();
 810
 811   TouchedSignalData data;
 812   TouchFunctor      functor(data);
 813   scene.TouchedSignal().Connect(&application, functor);
 814
 815   // Render and notify.
 816   application.SendNotification();
 817   application.Render();
 818
 819   // Confirm functor not called before there has been any touch event.
 820   DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 821
 822   // No actors, single touch, down, motion then up.
 823   {
 824     GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 825
 826     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 827     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 828     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 829
 830     data.Reset();
 831
 832     // Confirm there is no signal when the touchpoint is only moved.
 833     GenerateTouch(application, PointState::MOTION, Vector2(1200.0f, 10.0f)); // Some motion
 834
 835     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 836     data.Reset();
 837
 838     // Confirm a following up event generates a signal.
 839     GenerateTouch(application, PointState::UP, Vector2(1200.0f, 10.0f));
 840
 841     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 842     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 843     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 844     data.Reset();
 845   }
 846
 847   // Add an actor to the scene.
 848   Actor actor = Actor::New();
 849   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
 850   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 851   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 852   actor.TouchedSignal().Connect(&DummyTouchCallback);
 853   scene.Add(actor);
 854
 855   // Render and notify.
 856   application.SendNotification();
 857   application.Render();
 858
 859   // Actor on scene. Interrupted before down and interrupted after down.
 860   {
 861     GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
 862
 863     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 864     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 865     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 866     DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
 867     data.Reset();
 868
 869     GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 870
 871     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 872     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 873     DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0) == actor);
 874     DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::DOWN);
 875     data.Reset();
 876
 877     GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
 878
 879     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 880     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 881     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 882     DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
 883
 884     DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
 885
 886     // Check that getting info about a non-existent point returns an empty handle
 887     Actor actor = data.receivedTouchEvent.GetHitActor(1);
 888     DALI_TEST_CHECK(!actor);
 889
 890     data.Reset();
 891   }
 892
 893   END_TEST;
 894 }
 895
 896 int UtcDaliSceneSignalWheelEventP(void)
 897 {
 898   TestApplication          application;
 899   Dali::Integration::Scene scene = application.GetScene();
 900
 901   WheelEventSignalData      data;
 902   WheelEventReceivedFunctor functor(data);
 903   scene.WheelEventSignal().Connect(&application, functor);
 904
 905   Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
 906   application.ProcessEvent(event);
 907
 908   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 909   DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event.type) == data.receivedWheelEvent.GetType());
 910   DALI_TEST_CHECK(event.direction == data.receivedWheelEvent.GetDirection());
 911   DALI_TEST_CHECK(event.modifiers == data.receivedWheelEvent.GetModifiers());
 912   DALI_TEST_CHECK(event.point == data.receivedWheelEvent.GetPoint());
 913   DALI_TEST_CHECK(event.delta == data.receivedWheelEvent.GetDelta());
 914   DALI_TEST_CHECK(event.timeStamp == data.receivedWheelEvent.GetTime());
 915
 916   data.Reset();
 917
 918   Integration::WheelEvent event2(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1000u);
 919   application.ProcessEvent(event2);
 920
 921   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 922   DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event2.type) == data.receivedWheelEvent.GetType());
 923   DALI_TEST_CHECK(event2.direction == data.receivedWheelEvent.GetDirection());
 924   DALI_TEST_CHECK(event2.modifiers == data.receivedWheelEvent.GetModifiers());
 925   DALI_TEST_CHECK(event2.point == data.receivedWheelEvent.GetPoint());
 926   DALI_TEST_CHECK(event2.delta == data.receivedWheelEvent.GetDelta());
 927   DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime());
 928   END_TEST;
 929 }
 930
 931 int UtcDaliSceneSurfaceResizedDefaultScene(void)
 932 {
 933   tet_infoline("Ensure resizing of the surface is handled properly");
 934
 935   TestApplication application;
 936
 937   auto defaultScene = application.GetScene();
 938   DALI_TEST_CHECK(defaultScene);
 939
 940   // Ensure stage size matches the scene size
 941   auto stage = Stage::GetCurrent();
 942   DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
 943
 944   // Resize the scene
 945   Vector2 newSize(1000.0f, 2000.0f);
 946   DALI_TEST_CHECK(stage.GetSize() != newSize);
 947   defaultScene.SurfaceResized(newSize.width, newSize.height);
 948
 949   DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
 950   DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
 951
 952   END_TEST;
 953 }
 954
 955 int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void)
 956 {
 957   tet_infoline("Ensure resizing of the surface & viewport is handled properly");
 958
 959   TestApplication    application;
 960   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 961   TraceCallStack&    callStack     = glAbstraction.GetViewportTrace();
 962   glAbstraction.EnableViewportCallTrace(true);
 963
 964   // Initial scene setup
 965   Geometry geometry = CreateQuadGeometry();
 966   Shader   shader   = CreateShader();
 967   Renderer renderer = Renderer::New(geometry, shader);
 968
 969   Actor actor = Actor::New();
 970   actor.AddRenderer(renderer);
 971   actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
 972   application.GetScene().Add(actor);
 973
 974   // Render before resizing surface
 975   application.SendNotification();
 976   application.Render(0);
 977   glAbstraction.ResetViewportCallStack();
 978
 979   auto defaultScene = application.GetScene();
 980   DALI_TEST_CHECK(defaultScene);
 981
 982   // consume the resize flag by first rendering
 983   defaultScene.IsSurfaceRectChanged();
 984
 985   // Ensure stage size matches the scene size
 986   auto stage = Stage::GetCurrent();
 987   DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
 988
 989   Rect<int32_t> surfaceRect = defaultScene.GetCurrentSurfaceRect();
 990
 991   bool surfaceResized;
 992   // check resized flag before surface is resized.
 993   surfaceResized = defaultScene.IsSurfaceRectChanged();
 994   DALI_TEST_EQUALS(surfaceResized, false, TEST_LOCATION);
 995
 996   // Resize the scene
 997   Vector2     newSize(1000.0f, 2000.0f);
 998   std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
 999   DALI_TEST_CHECK(stage.GetSize() != newSize);
1000   defaultScene.SurfaceResized(newSize.width, newSize.height);
1001
1002   DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
1003   DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
1004
1005   // Check current surface rect
1006   Rect<int32_t> newSurfaceRect = defaultScene.GetCurrentSurfaceRect();
1007
1008   // It should not be changed yet.
1009   DALI_TEST_CHECK(surfaceRect == newSurfaceRect);
1010
1011   // Render after resizing surface
1012   application.SendNotification();
1013   application.Render(0);
1014
1015   surfaceResized = defaultScene.IsSurfaceRectChanged();
1016   DALI_TEST_EQUALS(surfaceResized, true, TEST_LOCATION);
1017
1018   // Check that the viewport is handled properly
1019   DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams));
1020
1021   // Check current surface rect
1022   newSurfaceRect = defaultScene.GetCurrentSurfaceRect();
1023
1024   // It should be changed
1025   DALI_TEST_EQUALS(newSurfaceRect.x, 0, TEST_LOCATION);
1026   DALI_TEST_EQUALS(newSurfaceRect.y, 0, TEST_LOCATION);
1027   DALI_TEST_EQUALS(newSurfaceRect.width, 1000, TEST_LOCATION);
1028   DALI_TEST_EQUALS(newSurfaceRect.height, 2000, TEST_LOCATION);
1029
1030   END_TEST;
1031 }
1032
1033 int UtcDaliSceneSurfaceResizedMultipleRenderTasks(void)
1034 {
1035   tet_infoline("Ensure resizing of the surface & viewport is handled properly");
1036
1037   TestApplication    application;
1038   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1039   TraceCallStack&    callStack     = glAbstraction.GetViewportTrace();
1040   glAbstraction.EnableViewportCallTrace(true);
1041
1042   // Initial scene setup
1043   auto scene = application.GetScene();
1044
1045   Geometry geometry = CreateQuadGeometry();
1046   Shader   shader   = CreateShader();
1047   Renderer renderer = Renderer::New(geometry, shader);
1048
1049   Actor actor = Actor::New();
1050   actor.AddRenderer(renderer);
1051   int testWidth  = 400;
1052   int testHeight = 400;
1053   actor.SetProperty(Actor::Property::SIZE, Vector2(testWidth, testHeight));
1054   scene.Add(actor);
1055
1056   CameraActor offscreenCameraActor = CameraActor::New(Size(testWidth, testHeight));
1057   application.GetScene().Add(offscreenCameraActor);
1058
1059   FrameBuffer newFrameBuffer = FrameBuffer::New(testWidth, testHeight, FrameBuffer::Attachment::NONE);
1060
1061   RenderTask newTask = scene.GetRenderTaskList().CreateTask();
1062   newTask.SetCameraActor(offscreenCameraActor);
1063   newTask.SetSourceActor(actor);
1064   newTask.SetFrameBuffer(newFrameBuffer);
1065   newTask.SetViewportPosition(Vector2(0, 0));
1066   newTask.SetViewportSize(Vector2(testWidth, testHeight));
1067
1068   // Render before resizing surface
1069   application.SendNotification();
1070   application.Render(0);
1071   glAbstraction.ResetViewportCallStack();
1072
1073   Rect<int32_t> initialViewport = newTask.GetViewport();
1074   int           initialWidth    = initialViewport.width;
1075   int           initialHeight   = initialViewport.height;
1076   DALI_TEST_EQUALS(initialWidth, testWidth, TEST_LOCATION);
1077   DALI_TEST_EQUALS(initialHeight, testHeight, TEST_LOCATION);
1078
1079   auto defaultScene = application.GetScene();
1080   DALI_TEST_CHECK(defaultScene);
1081
1082   // Ensure stage size matches the scene size
1083   auto stage = Stage::GetCurrent();
1084   DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
1085
1086   // Resize the scene
1087   Vector2     newSize(1000.0f, 2000.0f);
1088   std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
1089   DALI_TEST_CHECK(stage.GetSize() != newSize);
1090   defaultScene.SurfaceResized(newSize.width, newSize.height);
1091
1092   DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
1093   DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
1094
1095   // Render after resizing surface
1096   application.SendNotification();
1097   application.Render(0);
1098
1099   // Check that the viewport is handled properly
1100   DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams));
1101
1102   // Second render-task should not be affected
1103   Rect<int32_t> viewport = newTask.GetViewport();
1104   int           width    = viewport.width;
1105   int           height   = viewport.height;
1106   DALI_TEST_EQUALS(width, testWidth, TEST_LOCATION);
1107   DALI_TEST_EQUALS(height, testHeight, TEST_LOCATION);
1108
1109   END_TEST;
1110 }
1111
1112 int UtcDaliSceneSurfaceResizedAdditionalScene(void)
1113 {
1114   tet_infoline("Ensure resizing of the surface is handled properly on additional scenes");
1115
1116   TestApplication application;
1117   Vector2         originalSurfaceSize(500.0f, 1000.0f);
1118
1119   auto scene = Integration::Scene::New(Size(originalSurfaceSize.width, originalSurfaceSize.height));
1120
1121   // Ensure stage size does NOT match the surface size
1122   auto       stage     = Stage::GetCurrent();
1123   const auto stageSize = stage.GetSize();
1124   DALI_TEST_CHECK(stageSize != originalSurfaceSize);
1125   DALI_TEST_EQUALS(originalSurfaceSize, scene.GetSize(), TEST_LOCATION);
1126
1127   // Resize the surface and inform the scene accordingly
1128   Vector2 newSize(1000.0f, 2000.0f);
1129   DALI_TEST_CHECK(stage.GetSize() != newSize);
1130   scene.SurfaceResized(newSize.width, newSize.height);
1131
1132   // Ensure the stage hasn't been resized
1133   DALI_TEST_EQUALS(stage.GetSize(), stageSize, TEST_LOCATION);
1134   DALI_TEST_EQUALS(scene.GetSize(), newSize, TEST_LOCATION);
1135
1136   END_TEST;
1137 }
1138
1139 #define CLIPPING_RECT_X (16)
1140 #define CLIPPING_RECT_Y (768)
1141 #define CLIPPING_RECT_WIDTH (32)
1142 #define CLIPPING_RECT_HEIGHT (32)
1143
1144 int UtcDaliSceneSurfaceRotatedWithAngle0(void)
1145 {
1146   tet_infoline("Ensure rotation of the surface is handled properly with Angle 0");
1147
1148   TestApplication application(
1149     TestApplication::DEFAULT_SURFACE_WIDTH,
1150     TestApplication::DEFAULT_SURFACE_HEIGHT,
1151     TestApplication::DEFAULT_HORIZONTAL_DPI,
1152     TestApplication::DEFAULT_VERTICAL_DPI,
1153     true,
1154     true);
1155
1156   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1157
1158   std::vector<Rect<int>> damagedRects;
1159   Rect<int>              clippingRect;
1160   application.SendNotification();
1161   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1162
1163   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1164
1165   clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1166   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1167
1168   Actor actor = CreateRenderableActor();
1169   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1170   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1171   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1172   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1173   application.GetScene().Add(actor);
1174
1175   application.SendNotification();
1176
1177   damagedRects.clear();
1178   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1179                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1180                                         0);
1181
1182   // Check current surface orientation
1183   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1184
1185   // It should not be changed yet.
1186   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1187
1188   application.SendNotification();
1189   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1190   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1191
1192   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1193   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1194   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1195
1196   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1197   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1198   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1199   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1200
1201   // Check current surface orientation
1202   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1203
1204   // It should be changed.
1205   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1206
1207   END_TEST;
1208 }
1209
1210 int UtcDaliSceneSurfaceRotatedWithAngle90(void)
1211 {
1212   tet_infoline("Ensure rotation of the surface is handled properly with Angle 90");
1213
1214   TestApplication application(
1215     TestApplication::DEFAULT_SURFACE_WIDTH,
1216     TestApplication::DEFAULT_SURFACE_HEIGHT,
1217     TestApplication::DEFAULT_HORIZONTAL_DPI,
1218     TestApplication::DEFAULT_VERTICAL_DPI,
1219     true,
1220     true);
1221
1222   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1223
1224   std::vector<Rect<int>> damagedRects;
1225   Rect<int>              clippingRect;
1226   application.SendNotification();
1227   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1228
1229   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1230
1231   clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1232   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1233
1234   Actor actor = CreateRenderableActor();
1235   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1236   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1237   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1238   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1239   application.GetScene().Add(actor);
1240
1241   application.SendNotification();
1242
1243   damagedRects.clear();
1244   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1245                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1246                                         90);
1247
1248   // Check current surface orientation
1249   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1250
1251   // It should not be changed yet.
1252   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1253
1254   application.SendNotification();
1255   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1256   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1257
1258   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1259   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1260   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1261
1262   // It is recalculation for glScissor.
1263   // Because surface is rotated and glScissor is called with recalcurated value.
1264   clippingRect.x      = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1265   clippingRect.y      = CLIPPING_RECT_X;
1266   clippingRect.width  = CLIPPING_RECT_HEIGHT;
1267   clippingRect.height = CLIPPING_RECT_WIDTH;
1268
1269   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1270   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1271   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1272   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1273
1274   // Check current surface orientation
1275   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1276
1277   // It should be changed.
1278   DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION);
1279
1280   END_TEST;
1281 }
1282
1283 int UtcDaliSceneSurfaceRotatedWithAngle180(void)
1284 {
1285   tet_infoline("Ensure rotation of the surface is handled properly with Angle 180");
1286
1287   TestApplication application(
1288     TestApplication::DEFAULT_SURFACE_WIDTH,
1289     TestApplication::DEFAULT_SURFACE_HEIGHT,
1290     TestApplication::DEFAULT_HORIZONTAL_DPI,
1291     TestApplication::DEFAULT_VERTICAL_DPI,
1292     true,
1293     true);
1294
1295   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1296
1297   std::vector<Rect<int>> damagedRects;
1298   Rect<int>              clippingRect;
1299   application.SendNotification();
1300   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1301
1302   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1303
1304   clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1305   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1306
1307   Actor actor = CreateRenderableActor();
1308   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1309   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1310   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1311   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1312   application.GetScene().Add(actor);
1313
1314   application.SendNotification();
1315
1316   damagedRects.clear();
1317   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1318                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1319                                         180);
1320
1321   // Check current surface orientation
1322   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1323
1324   // It should not be changed yet.
1325   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1326
1327   application.SendNotification();
1328   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1329   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1330
1331   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1332   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1333   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1334
1335   // It is recalculation for glScissor.
1336   // Because surface is rotated and glScissor is called with recalcurated value.
1337   clippingRect.x      = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1338   clippingRect.y      = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1339   clippingRect.width  = CLIPPING_RECT_WIDTH;
1340   clippingRect.height = CLIPPING_RECT_HEIGHT;
1341
1342   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1343   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1344   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1345   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1346
1347   // Check current surface orientation
1348   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1349
1350   // It should be changed.
1351   DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION);
1352
1353   END_TEST;
1354 }
1355
1356 int UtcDaliSceneSurfaceRotatedWithAngle270(void)
1357 {
1358   tet_infoline("Ensure rotation of the surface is handled properly with Angle 270");
1359
1360   TestApplication application(
1361     TestApplication::DEFAULT_SURFACE_WIDTH,
1362     TestApplication::DEFAULT_SURFACE_HEIGHT,
1363     TestApplication::DEFAULT_HORIZONTAL_DPI,
1364     TestApplication::DEFAULT_VERTICAL_DPI,
1365     true,
1366     true);
1367
1368   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1369
1370   std::vector<Rect<int>> damagedRects;
1371   Rect<int>              clippingRect;
1372   application.SendNotification();
1373   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1374
1375   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1376
1377   clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1378   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1379
1380   Actor actor = CreateRenderableActor();
1381   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1382   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1383   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1384   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1385   application.GetScene().Add(actor);
1386
1387   application.SendNotification();
1388
1389   damagedRects.clear();
1390   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1391                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1392                                         270);
1393
1394   // Check current surface orientation
1395   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1396
1397   // It should not be changed yet.
1398   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1399
1400   application.SendNotification();
1401   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1402   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1403
1404   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1405   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1406   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1407
1408   // It is recalculation for glScissor.
1409   // Because surface is rotated and glScissor is called with recalcurated value.
1410   clippingRect.x      = CLIPPING_RECT_Y;
1411   clippingRect.y      = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1412   clippingRect.width  = CLIPPING_RECT_HEIGHT;
1413   clippingRect.height = CLIPPING_RECT_WIDTH;
1414
1415   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1416   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1417   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1418   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1419
1420   // Check current surface orientation
1421   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1422
1423   // It should be changed.
1424   DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION);
1425
1426   END_TEST;
1427 }
1428
1429 int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void)
1430 {
1431   tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton");
1432
1433   TestApplication application(
1434     TestApplication::DEFAULT_SURFACE_WIDTH,
1435     TestApplication::DEFAULT_SURFACE_HEIGHT,
1436     TestApplication::DEFAULT_HORIZONTAL_DPI,
1437     TestApplication::DEFAULT_VERTICAL_DPI,
1438     true,
1439     true);
1440
1441   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1442
1443   std::vector<Rect<int>> damagedRects;
1444   Rect<int>              clippingRect;
1445   application.SendNotification();
1446   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1447
1448   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1449   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1450
1451   Actor actor = CreateRenderableActor();
1452   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1453   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1454   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1455   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1456   application.GetScene().Add(actor);
1457
1458   application.SendNotification();
1459
1460   damagedRects.clear();
1461   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1462                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1463                                         90);
1464
1465   // Check current surface orientation
1466   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1467
1468   // It should not be changed yet.
1469   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1470
1471   application.GetScene().SetRotationCompletedAcknowledgement();
1472
1473   application.SendNotification();
1474   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1475   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1476
1477   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1478   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1479   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1480
1481   // It is recalculation for glScissor.
1482   // Because surface is rotated and glScissor is called with recalcurated value.
1483   clippingRect.x      = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1484   clippingRect.y      = CLIPPING_RECT_X;
1485   clippingRect.width  = CLIPPING_RECT_HEIGHT;
1486   clippingRect.height = CLIPPING_RECT_WIDTH;
1487
1488   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1489   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1490   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1491   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1492
1493   // Check current surface orientation
1494   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1495
1496   // It should be changed.
1497   DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION);
1498
1499   bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet();
1500   DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION);
1501
1502   END_TEST;
1503 }
1504
1505
1506
1507 int UtcDaliSceneKeyEventGeneratedSignalP(void)
1508 {
1509   TestApplication          application;
1510   Dali::Integration::Scene scene = application.GetScene();
1511
1512   KeyEventGeneratedSignalData      data;
1513   KeyEventGeneratedReceivedFunctor functor(data);
1514   scene.KeyEventGeneratedSignal().Connect(&application, functor);
1515
1516   Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1517   application.ProcessEvent(event);
1518
1519   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1520   DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1521   DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
1522   DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
1523   DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1524
1525   data.Reset();
1526
1527   Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1528   application.ProcessEvent(event2);
1529
1530   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1531   DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1532   DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
1533   DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
1534   DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1535
1536   data.Reset();
1537
1538   Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1539   application.ProcessEvent(event3);
1540
1541   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1542   DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1543   DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
1544   DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
1545   DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1546
1547   data.Reset();
1548
1549   Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1550   application.ProcessEvent(event4);
1551
1552   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1553   DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1554   DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
1555   DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
1556   DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1557   END_TEST;
1558 }
1559
1560 int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void)
1561 {
1562   tet_infoline("Ensure we keep background color when the scene surface is replaced ");
1563
1564   TestApplication application;
1565
1566   // Create a new scene and set the background color of the main scene
1567   auto defaultScene = application.GetScene();
1568   defaultScene.SetBackgroundColor(Color::BLUE);
1569
1570   // Need to create a renderable as we don't start rendering until we have at least one
1571   // We don't need to add this to any scene
1572   auto actor = CreateRenderableActor();
1573
1574   auto& glAbstraction    = application.GetGlAbstraction();
1575   auto  clearCountBefore = glAbstraction.GetClearCountCalled();
1576
1577   application.SendNotification();
1578   application.Render();
1579
1580   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION);
1581   DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
1582
1583   defaultScene.SurfaceReplaced();
1584
1585   application.SendNotification();
1586   application.Render();
1587
1588   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION);
1589   DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
1590
1591   // Check when the main render task viewport is set the clear color is clipped using scissors
1592   TraceCallStack& scissorTrace        = glAbstraction.GetScissorTrace();
1593   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
1594   scissorTrace.Enable(true);
1595   enabledDisableTrace.Enable(true);
1596
1597   defaultScene.GetRenderTaskList().GetTask(0).SetViewport(Viewport(0.0f, 0.0f, 100.0f, 100.0f));
1598
1599   application.SendNotification();
1600   application.Render();
1601
1602   // Check scissor test was enabled.
1603   std::ostringstream scissor;
1604   scissor << std::hex << GL_SCISSOR_TEST;
1605   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
1606
1607   // Check the scissor was set, and the coordinates are correct.
1608   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", "0, 700, 100, 100"));
1609
1610   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION);
1611   DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
1612
1613   scissorTrace.Enable(false);
1614   scissorTrace.Reset();
1615
1616   enabledDisableTrace.Enable(false);
1617   enabledDisableTrace.Reset();
1618
1619   END_TEST;
1620 }
1621
1622 int UtcDaliSceneEmptySceneRendering(void)
1623 {
1624   tet_infoline("Ensure not rendering before a Renderer is added");
1625
1626   TestApplication    application;
1627   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1628
1629   // Render without any renderer
1630   application.SendNotification();
1631   application.Render();
1632
1633   // Check the clear count and the render status
1634   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION);
1635   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), false, TEST_LOCATION);
1636
1637   // Add a Renderer
1638   Geometry geometry = CreateQuadGeometry();
1639   Shader   shader   = CreateShader();
1640   Renderer renderer = Renderer::New(geometry, shader);
1641
1642   // Render before adding renderer
1643   application.SendNotification();
1644   application.Render();
1645
1646   // Check the clear count and the render status
1647   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION);
1648   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), false, TEST_LOCATION);
1649
1650   Actor actor = Actor::New();
1651   actor.AddRenderer(renderer);
1652
1653   actor.SetProperty(Actor::Property::SIZE, Vector2(400, 400));
1654   application.GetScene().Add(actor);
1655
1656   // Render
1657   application.SendNotification();
1658   application.Render();
1659
1660   // Check the clear count and the render status
1661   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 1, TEST_LOCATION);
1662   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
1663
1664   // Remove the Renderer
1665   application.GetScene().Remove(actor);
1666   actor.Reset();
1667   renderer.Reset();
1668
1669   // Render
1670   application.SendNotification();
1671   application.Render();
1672
1673   // Check the clear count and the render status
1674   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 2, TEST_LOCATION); // Should be cleared
1675   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
1676
1677   END_TEST;
1678 }
1679
1680 int UtcDaliSceneFrameRenderedPresentedCallback(void)
1681 {
1682   tet_infoline("UtcDaliSceneFrameRenderedCallback");
1683
1684   TestApplication application;
1685
1686   // Add a Renderer
1687   Geometry geometry = CreateQuadGeometry();
1688   Shader   shader   = CreateShader();
1689   Renderer renderer = Renderer::New(geometry, shader);
1690
1691   Actor actor = Actor::New();
1692   actor.AddRenderer(renderer);
1693   application.GetScene().Add(actor);
1694
1695   Dali::Integration::Scene scene = application.GetScene();
1696
1697   int frameId = 1;
1698   scene.AddFrameRenderedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
1699   scene.AddFramePresentedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
1700
1701   // Render
1702   application.SendNotification();
1703   application.Render();
1704
1705   Dali::Integration::Scene::FrameCallbackContainer callbackContainer;
1706   scene.GetFrameRenderedCallback(callbackContainer);
1707
1708   DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
1709   DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
1710
1711   callbackContainer.clear();
1712
1713   scene.GetFramePresentedCallback(callbackContainer);
1714
1715   DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
1716   DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
1717
1718   END_TEST;
1719 }
1720
1721 int UtcDaliSceneWheelEventGeneratedSignalP(void)
1722 {
1723   TestApplication          application;
1724   Dali::Integration::Scene scene = application.GetScene();
1725
1726   WheelEventGeneratedSignalData      data;
1727   WheelEventGeneratedReceivedFunctor functor(data);
1728   scene.WheelEventGeneratedSignal().Connect(&application, functor);
1729
1730   Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
1731   application.ProcessEvent(event);
1732
1733   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1734   DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event.type) == data.receivedWheelEvent.GetType());
1735   DALI_TEST_CHECK(event.direction == data.receivedWheelEvent.GetDirection());
1736   DALI_TEST_CHECK(event.modifiers == data.receivedWheelEvent.GetModifiers());
1737   DALI_TEST_CHECK(event.point == data.receivedWheelEvent.GetPoint());
1738   DALI_TEST_CHECK(event.delta == data.receivedWheelEvent.GetDelta());
1739   DALI_TEST_CHECK(event.timeStamp == data.receivedWheelEvent.GetTime());
1740
1741   data.Reset();
1742
1743   Integration::WheelEvent event2(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1000u);
1744   application.ProcessEvent(event2);
1745
1746   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1747   DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event2.type) == data.receivedWheelEvent.GetType());
1748   DALI_TEST_CHECK(event2.direction == data.receivedWheelEvent.GetDirection());
1749   DALI_TEST_CHECK(event2.modifiers == data.receivedWheelEvent.GetModifiers());
1750   DALI_TEST_CHECK(event2.point == data.receivedWheelEvent.GetPoint());
1751   DALI_TEST_CHECK(event2.delta == data.receivedWheelEvent.GetDelta());
1752   DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime());
1753   END_TEST;
1754 }