X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-Scene.cpp;h=959e5ee548053c7695b99addb8ba63dbe156e224;hb=eacc080fe975c523d722dd17c044652317ddd6e8;hp=290d896129201da1f22ffde0cebf474ab774e44f;hpb=5abd8d9a30e5e1dfbd26cbec2c3d64d87128cd70;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/automated-tests/src/dali/utc-Dali-Scene.cpp b/automated-tests/src/dali/utc-Dali-Scene.cpp index 290d896..959e5ee 100644 --- a/automated-tests/src/dali/utc-Dali-Scene.cpp +++ b/automated-tests/src/dali/utc-Dali-Scene.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -224,6 +224,50 @@ struct KeyEventGeneratedReceivedFunctor KeyEventGeneratedSignalData& signalData; }; +// Stores data that is populated in the WheelEventGeneratedSignal callback and will be read by the TET cases +struct WheelEventGeneratedSignalData +{ + WheelEventGeneratedSignalData() + : functorCalled(false) + { + } + + void Reset() + { + functorCalled = false; + + receivedWheelEvent.Reset(); + } + + bool functorCalled; + WheelEvent receivedWheelEvent; +}; + +// Functor that sets the data when called +struct WheelEventGeneratedReceivedFunctor +{ + WheelEventGeneratedReceivedFunctor(WheelEventGeneratedSignalData& data) + : signalData(data) + { + } + + bool operator()(const WheelEvent& wheelEvent) + { + signalData.functorCalled = true; + signalData.receivedWheelEvent = wheelEvent; + + return true; + } + + bool operator()() + { + signalData.functorCalled = true; + return true; + } + + WheelEventGeneratedSignalData& signalData; +}; + void GenerateTouch(TestApplication& application, PointState::Type state, const Vector2& screenPosition) { Integration::TouchEvent touchEvent; @@ -385,12 +429,26 @@ int UtcDaliSceneGet(void) Dali::Integration::Scene scene = application.GetScene(); - Actor actor = Actor::New(); - DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(actor)); + Actor parent = Actor::New(); + Actor child = Actor::New(); - scene.Add(actor); + parent.Add(child); + + // Should be empty scene + DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(parent)); + DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(child)); - DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(actor)); + scene.Add(parent); + + // Should return the valid scene + DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(parent)); + DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(child)); + + parent.Unparent(); + + // Should be empty scene + DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(parent)); + DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(child)); END_TEST; } @@ -928,6 +986,8 @@ int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void) auto stage = Stage::GetCurrent(); DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION); + Rect surfaceRect = defaultScene.GetCurrentSurfaceRect(); + bool surfaceResized; // check resized flag before surface is resized. surfaceResized = defaultScene.IsSurfaceRectChanged(); @@ -942,6 +1002,12 @@ int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void) DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION); DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION); + // Check current surface rect + Rect newSurfaceRect = defaultScene.GetCurrentSurfaceRect(); + + // It should not be changed yet. + DALI_TEST_CHECK(surfaceRect == newSurfaceRect); + // Render after resizing surface application.SendNotification(); application.Render(0); @@ -950,7 +1016,16 @@ int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void) DALI_TEST_EQUALS(surfaceResized, true, TEST_LOCATION); // Check that the viewport is handled properly - DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams)); + DALI_TEST_CHECK(callStack.FindIndexFromMethodAndParams("Viewport", viewportParams) >= 0); + + // Check current surface rect + newSurfaceRect = defaultScene.GetCurrentSurfaceRect(); + + // It should be changed + DALI_TEST_EQUALS(newSurfaceRect.x, 0, TEST_LOCATION); + DALI_TEST_EQUALS(newSurfaceRect.y, 0, TEST_LOCATION); + DALI_TEST_EQUALS(newSurfaceRect.width, 1000, TEST_LOCATION); + DALI_TEST_EQUALS(newSurfaceRect.height, 2000, TEST_LOCATION); END_TEST; } @@ -1086,6 +1161,8 @@ int UtcDaliSceneSurfaceRotatedWithAngle0(void) application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; application.RenderWithPartialUpdate(damagedRects, clippingRect); Actor actor = CreateRenderableActor(); @@ -1095,12 +1172,22 @@ int UtcDaliSceneSurfaceRotatedWithAngle0(void) actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); application.GetScene().Add(actor); + // consume the orientating changing flag by first rendering application.SendNotification(); damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 0); + 0, 0); + + // Check current orientations + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); @@ -1114,6 +1201,14 @@ int UtcDaliSceneSurfaceRotatedWithAngle0(void) DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + END_TEST; } @@ -1137,6 +1232,8 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; application.RenderWithPartialUpdate(damagedRects, clippingRect); Actor actor = CreateRenderableActor(); @@ -1151,7 +1248,16 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 90); + 90, 0); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); @@ -1162,6 +1268,7 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 90, (90 + 0 = 90) clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); clippingRect.y = CLIPPING_RECT_X; clippingRect.width = CLIPPING_RECT_HEIGHT; @@ -1172,12 +1279,20 @@ int UtcDaliSceneSurfaceRotatedWithAngle90(void) DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + END_TEST; } -int UtcDaliSceneSurfaceRotatedWithAngle180(void) +int UtcDaliSceneScreenRotatedWithAngle90(void) { - tet_infoline("Ensure rotation of the surface is handled properly with Angle 180"); + tet_infoline("Ensure rotation of the screen is handled properly with Angle 90"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1195,6 +1310,8 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; application.RenderWithPartialUpdate(damagedRects, clippingRect); Actor actor = CreateRenderableActor(); @@ -1209,7 +1326,16 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 180); + 0, 90); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); @@ -1220,22 +1346,31 @@ int UtcDaliSceneSurfaceRotatedWithAngle180(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. - clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); - clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); - clippingRect.width = CLIPPING_RECT_WIDTH; - clippingRect.height = CLIPPING_RECT_HEIGHT; + // Total angle is 90, (0 + 90 = 90) + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); + END_TEST; } -int UtcDaliSceneSurfaceRotatedWithAngle270(void) +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle90(void) { - tet_infoline("Ensure rotation of the surface is handled properly with Angle 270"); + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 90"); TestApplication application( TestApplication::DEFAULT_SURFACE_WIDTH, @@ -1253,6 +1388,8 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; application.RenderWithPartialUpdate(damagedRects, clippingRect); Actor actor = CreateRenderableActor(); @@ -1267,7 +1404,16 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) damagedRects.clear(); application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT, - 270); + 90, 90); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + application.SendNotification(); application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); @@ -1278,137 +1424,965 @@ int UtcDaliSceneSurfaceRotatedWithAngle270(void) // It is recalculation for glScissor. // Because surface is rotated and glScissor is called with recalcurated value. - clippingRect.x = CLIPPING_RECT_Y; - clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); - clippingRect.width = CLIPPING_RECT_HEIGHT; - clippingRect.height = CLIPPING_RECT_WIDTH; + // Total angle is 180.(90 + 90 = 180) + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); + END_TEST; } -int UtcDaliSceneKeyEventGeneratedSignalP(void) +int UtcDaliSceneSurfaceRotatedWithAngle180(void) { - TestApplication application; - Dali::Integration::Scene scene = application.GetScene(); + tet_infoline("Ensure rotation of the surface is handled properly with Angle 180"); - KeyEventGeneratedSignalData data; - KeyEventGeneratedReceivedFunctor functor(data); - scene.KeyEventGeneratedSignal().Connect(&application, functor); + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); - Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); - application.ProcessEvent(event); + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); - DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); - DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier()); - DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName()); - DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString()); - DALI_TEST_CHECK(event.state == static_cast(data.receivedKeyEvent.GetState())); + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); - data.Reset(); + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); - Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); - application.ProcessEvent(event2); + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); - DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); - DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier()); - DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName()); - DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString()); - DALI_TEST_CHECK(event2.state == static_cast(data.receivedKeyEvent.GetState())); + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); - data.Reset(); + application.SendNotification(); - Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); - application.ProcessEvent(event3); + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 180, 0); - DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); - DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier()); - DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName()); - DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString()); - DALI_TEST_CHECK(event3.state == static_cast(data.receivedKeyEvent.GetState())); + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); - data.Reset(); + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); - Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); - application.ProcessEvent(event4); + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); - DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); - DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier()); - DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName()); - DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString()); - DALI_TEST_CHECK(event4.state == static_cast(data.receivedKeyEvent.GetState())); END_TEST; } -int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void) +int UtcDaliSceneScreenRotatedWithAngle180(void) { - tet_infoline("Ensure we keep background color when the scene surface is replaced "); - - TestApplication application; - - // Create a new scene and set the background color of the main scene - auto defaultScene = application.GetScene(); - defaultScene.SetBackgroundColor(Color::BLUE); + tet_infoline("Ensure rotation of the screen is handled properly with Angle 180"); - // Need to create a renderable as we don't start rendering until we have at least one - // We don't need to add this to any scene - auto actor = CreateRenderableActor(); + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); - auto& glAbstraction = application.GetGlAbstraction(); - auto clearCountBefore = glAbstraction.GetClearCountCalled(); + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + std::vector> damagedRects; + Rect clippingRect; application.SendNotification(); - application.Render(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); - DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION); - DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); - defaultScene.SurfaceReplaced(); + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); application.SendNotification(); - application.Render(); - DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION); - DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 0, 180); - // Check when the main render task viewport is set the clear color is clipped using scissors - TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace(); - TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace(); - scissorTrace.Enable(true); - enabledDisableTrace.Enable(true); + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); - defaultScene.GetRenderTaskList().GetTask(0).SetViewport(Viewport(0.0f, 0.0f, 100.0f, 100.0f)); + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); application.SendNotification(); - application.Render(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); - // Check scissor test was enabled. - std::ostringstream scissor; - scissor << std::hex << GL_SCISSOR_TEST; - DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str())); + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); - // Check the scissor was set, and the coordinates are correct. - DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", "0, 700, 100, 100")); + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; - DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION); - DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); - scissorTrace.Enable(false); - scissorTrace.Reset(); + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); - enabledDisableTrace.Enable(false); - enabledDisableTrace.Reset(); + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION); END_TEST; } -int UtcDaliSceneEmptySceneRendering(void) +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle180(void) { - tet_infoline("Ensure not rendering before a Renderer is added"); + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 180"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + // consume the orientating changing flag by first rendering + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 180, 180); + + // Check current orientations + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 180, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceRotatedWithAngle270(void) +{ + tet_infoline("Ensure rotation of the surface is handled properly with Angle 270"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 270, 0); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 270. (270 + 0 = 270) + clippingRect.x = CLIPPING_RECT_Y; + clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneScreenRotatedWithAngle270(void) +{ + tet_infoline("Ensure rotation of the screen is handled properly with Angle 270"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 0, 270); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 270. (0 + 270 = 270) + clippingRect.x = CLIPPING_RECT_Y; + clippingRect.y = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceAndScreenRotatedWithAngle270(void) +{ + tet_infoline("Ensure rotation of the surface and the screen is handled properly with Angle 270"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 270, 270); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + // Total angle is 180.(270 + 270 - 360 = 180) + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 270, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSetSurfaceRotationCompletedAcknowledgementWithAngle90(void) +{ + tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 90, 0); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.GetScene().SetRotationCompletedAcknowledgement(); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSetScreenRotationCompletedAcknowledgementWithAngle90(void) +{ + tet_infoline("Ensure to acknowledge for completing screen 90 angle rotaiton"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 0, 90); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.GetScene().SetRotationCompletedAcknowledgement(); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.y = CLIPPING_RECT_X; + clippingRect.width = CLIPPING_RECT_HEIGHT; + clippingRect.height = CLIPPING_RECT_WIDTH; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSetSurfaceAndScreenRotationCompletedAcknowledgementWithAngle90(void) +{ + tet_infoline("Ensure to acknowledge for completing surface and screen 90 angle rotaiton"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT); + actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + + damagedRects.clear(); + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + 90, 90); + + // Check current surface orientation + int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation(); + int32_t screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should not be changed yet. + DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 0, TEST_LOCATION); + + application.GetScene().SetRotationCompletedAcknowledgement(); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + + clippingRect = Rect(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // It is recalculation for glScissor. + // Because surface is rotated and glScissor is called with recalcurated value. + clippingRect.x = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH); + clippingRect.y = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT); + clippingRect.width = CLIPPING_RECT_WIDTH; + clippingRect.height = CLIPPING_RECT_HEIGHT; + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + // Check current orientations + orientation = application.GetScene().GetCurrentSurfaceOrientation(); + screenOrientation = application.GetScene().GetCurrentScreenOrientation(); + + // It should be changed. + DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION); + DALI_TEST_EQUALS(screenOrientation, 90, TEST_LOCATION); + + bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet(); + DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceRotatedPartialUpdate(void) +{ + tet_infoline("Ensure rotation of the surface and partial update are handled properly"); + + TestApplication application( + TestApplication::DEFAULT_SURFACE_WIDTH, + TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_HORIZONTAL_DPI, + TestApplication::DEFAULT_VERTICAL_DPI, + true, + true); + + const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams()); + + std::vector> damagedRects; + Rect clippingRect; + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + clippingRect = TestApplication::DEFAULT_SURFACE_RECT; + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + Actor actor = CreateRenderableActor(); + actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + actor.SetProperty(Actor::Property::SIZE, Vector3(32.0f, 32.0f, 0.0f)); + actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS); + application.GetScene().Add(actor); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + clippingRect = Rect(224, 384, 48, 48); // in screen coordinates + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION); + DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION); + + damagedRects.clear(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + damagedRects.clear(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + // Ensure the damaged rect is empty + DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION); + + // Rotate surface + application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_HEIGHT, + TestApplication::DEFAULT_SURFACE_WIDTH, + 90, 0); + + damagedRects.clear(); + + application.SendNotification(); + application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects); + + clippingRect = Rect(224, 224, 208, 208); // in screen coordinates, merged value with the previous rect + DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION); + DALI_TEST_EQUALS>(clippingRect, damagedRects[0], TEST_LOCATION); + + application.RenderWithPartialUpdate(damagedRects, clippingRect); + + END_TEST; +} + +int UtcDaliSceneKeyEventGeneratedSignalP(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + KeyEventGeneratedSignalData data; + KeyEventGeneratedReceivedFunctor functor(data); + scene.KeyEventGeneratedSignal().Connect(&application, functor); + + Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event.state == static_cast(data.receivedKeyEvent.GetState())); + + data.Reset(); + + Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event2); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event2.state == static_cast(data.receivedKeyEvent.GetState())); + + data.Reset(); + + Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event3); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event3.state == static_cast(data.receivedKeyEvent.GetState())); + + data.Reset(); + + Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event4); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event4.state == static_cast(data.receivedKeyEvent.GetState())); + END_TEST; +} + +int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void) +{ + tet_infoline("Ensure we keep background color when the scene surface is replaced "); + + TestApplication application; + + // Create a new scene and set the background color of the main scene + auto defaultScene = application.GetScene(); + defaultScene.SetBackgroundColor(Color::BLUE); + + // Need to create a renderable as we don't start rendering until we have at least one + // We don't need to add this to any scene + auto actor = CreateRenderableActor(); + + auto& glAbstraction = application.GetGlAbstraction(); + auto clearCountBefore = glAbstraction.GetClearCountCalled(); + + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION); + DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + + defaultScene.SurfaceReplaced(); + + application.SendNotification(); + application.Render(); + + DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION); + DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + + // Check when the main render task viewport is set the clear color is clipped using scissors + TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace(); + TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace(); + scissorTrace.Enable(true); + enabledDisableTrace.Enable(true); + + defaultScene.GetRenderTaskList().GetTask(0).SetViewport(Viewport(0.0f, 0.0f, 100.0f, 100.0f)); + + application.SendNotification(); + application.Render(); + + // Check scissor test was enabled. + std::ostringstream scissor; + scissor << std::hex << GL_SCISSOR_TEST; + DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str())); + + // Check the scissor was set, and the coordinates are correct. + DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", "0, 700, 100, 100")); + + DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION); + DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION); + + scissorTrace.Enable(false); + scissorTrace.Reset(); + + enabledDisableTrace.Enable(false); + enabledDisableTrace.Reset(); + + END_TEST; +} + +int UtcDaliSceneEnsureRenderTargetRecreated(void) +{ + tet_infoline("Ensure render target is re-created when surface replaced "); + + TestApplication application; + + // Create a new scene and set the background color of the main scene + auto defaultScene = application.GetScene(); + defaultScene.SetBackgroundColor(Color::BLUE); + + auto actor = CreateRenderableActor(); + defaultScene.Add(actor); + + auto& graphicsController = application.GetGraphicsController(); + + application.SendNotification(); + application.Render(); + + TraceCallStack& graphicsCallStack = graphicsController.mCallStack; + TraceCallStack::NamedParams empty{}; + const TraceCallStack::NamedParams* matching = graphicsCallStack.FindLastMatch("PresentRenderTarget", empty); + DALI_TEST_CHECK(matching != nullptr); + + graphicsCallStack.Reset(); + + int fakeSurface1; + Graphics::RenderTargetCreateInfo createInfo{}; + createInfo.SetSurface(&fakeSurface1).SetExtent(Graphics::Extent2D{480u, 800u}); + defaultScene.SetSurfaceRenderTarget(createInfo); + + application.SendNotification(); + application.Render(); + + TraceCallStack::NamedParams query1; + query1["surface"] << std::hex << &fakeSurface1; + const TraceCallStack::NamedParams* matching2 = graphicsCallStack.FindLastMatch("CreateRenderTarget", query1); + DALI_TEST_CHECK(matching2 != nullptr); + + const TraceCallStack::NamedParams* matching3 = graphicsCallStack.FindLastMatch("PresentRenderTarget", empty); + DALI_TEST_CHECK(matching3 != nullptr); + DALI_TEST_EQUALS((*matching3)["surface"].str(), query1["surface"].str(), TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneEmptySceneRendering(void) +{ + tet_infoline("Ensure not rendering before a Renderer is added"); TestApplication application; TestGlAbstraction& glAbstraction = application.GetGlAbstraction(); @@ -1504,3 +2478,200 @@ int UtcDaliSceneFrameRenderedPresentedCallback(void) END_TEST; } + +int UtcDaliSceneWheelEventGeneratedSignalP(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + WheelEventGeneratedSignalData data; + WheelEventGeneratedReceivedFunctor functor(data); + scene.WheelEventGeneratedSignal().Connect(&application, functor); + + Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u); + application.ProcessEvent(event); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(static_cast(event.type) == data.receivedWheelEvent.GetType()); + DALI_TEST_CHECK(event.direction == data.receivedWheelEvent.GetDirection()); + DALI_TEST_CHECK(event.modifiers == data.receivedWheelEvent.GetModifiers()); + DALI_TEST_CHECK(event.point == data.receivedWheelEvent.GetPoint()); + DALI_TEST_CHECK(event.delta == data.receivedWheelEvent.GetDelta()); + DALI_TEST_CHECK(event.timeStamp == data.receivedWheelEvent.GetTime()); + + data.Reset(); + + Integration::WheelEvent event2(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1000u); + application.ProcessEvent(event2); + + DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(static_cast(event2.type) == data.receivedWheelEvent.GetType()); + DALI_TEST_CHECK(event2.direction == data.receivedWheelEvent.GetDirection()); + DALI_TEST_CHECK(event2.modifiers == data.receivedWheelEvent.GetModifiers()); + DALI_TEST_CHECK(event2.point == data.receivedWheelEvent.GetPoint()); + DALI_TEST_CHECK(event2.delta == data.receivedWheelEvent.GetDelta()); + DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime()); + END_TEST; +} + +int UtcDaliSceneSignalInterceptKeyEventP(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + KeyEventSignalData data; + KeyEventReceivedFunctor functor(data); + scene.KeyEventSignal().Connect(&application, functor); + + KeyEventGeneratedSignalData interceptData; + KeyEventGeneratedReceivedFunctor interceptFunctor(interceptData); + scene.InterceptKeyEventSignal().Connect(&application, interceptFunctor); + + Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + data.Reset(); + interceptData.Reset(); + + Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event2); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event2.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event2.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event2.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event2.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + data.Reset(); + interceptData.Reset(); + + Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event3); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event3.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event3.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event3.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event3.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + data.Reset(); + interceptData.Reset(); + + Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE); + application.ProcessEvent(event4); + + DALI_TEST_EQUALS(true, interceptData.functorCalled, TEST_LOCATION); + DALI_TEST_CHECK(event4.keyModifier == interceptData.receivedKeyEvent.GetKeyModifier()); + DALI_TEST_CHECK(event4.keyName == interceptData.receivedKeyEvent.GetKeyName()); + DALI_TEST_CHECK(event4.keyString == interceptData.receivedKeyEvent.GetKeyString()); + DALI_TEST_CHECK(event4.state == static_cast(interceptData.receivedKeyEvent.GetState())); + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + END_TEST; +} + +int UtcDaliSceneSignalInterceptKeyEventN(void) +{ + TestApplication application; + Dali::Integration::Scene scene = application.GetScene(); + + KeyEventGeneratedSignalData data; + KeyEventGeneratedReceivedFunctor functor(data); + scene.InterceptKeyEventSignal().Connect(&application, functor); + + // Check that a non-pressed key events data is not modified. + DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneGetOverlayLayer(void) +{ + TestApplication application; + tet_infoline("Testing Dali::Integration::Scene::GetOverlayLayer"); + + Dali::Integration::Scene scene = application.GetScene(); + + // Check we get a valid instance. + RenderTaskList tasks = scene.GetRenderTaskList(); + + // There should be 1 task by default. + DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION); + RenderTask defaultTask = tasks.GetTask(0u); + DALI_TEST_EQUALS(scene.GetRootLayer(), defaultTask.GetSourceActor(), TEST_LOCATION); + + Layer layer = scene.GetOverlayLayer(); + // There should be 2 task by default. + DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION); + RenderTask overlayTask = tasks.GetTask(1u); + DALI_TEST_EQUALS(overlayTask, tasks.GetOverlayTask(), TEST_LOCATION); + DALI_TEST_CHECK(scene.GetRootLayer() != overlayTask.GetSourceActor()); + DALI_TEST_CHECK(overlayTask != defaultTask); + DALI_TEST_EQUALS(overlayTask.GetClearEnabled(), false, TEST_LOCATION); + DALI_TEST_EQUALS(overlayTask.IsExclusive(), true, TEST_LOCATION); + + // If new render task is created, the last task is overlayTask + RenderTask newTask = scene.GetRenderTaskList().CreateTask(); + DALI_TEST_EQUALS(tasks.GetTaskCount(), 3u, TEST_LOCATION); + DALI_TEST_EQUALS(newTask, tasks.GetTask(1u), TEST_LOCATION); + DALI_TEST_EQUALS(overlayTask, tasks.GetTask(2u), TEST_LOCATION); + + // Render + application.SendNotification(); + application.Render(); + + tasks.RemoveTask(overlayTask); + DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION); + DALI_TEST_EQUALS(tasks.GetTask(0u), defaultTask, TEST_LOCATION); + DALI_TEST_EQUALS(tasks.GetTask(1u), newTask, TEST_LOCATION); + + END_TEST; +} + +int UtcDaliSceneSurfaceResizedWithOverlayLayer(void) +{ + tet_infoline("Ensure resizing of the surface is handled properly"); + + TestApplication application; + + auto scene = application.GetScene(); + DALI_TEST_CHECK(scene); + + const RenderTaskList& tasks = scene.GetRenderTaskList(); + DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION); + RenderTask defaultTask = tasks.GetTask(0u); + DALI_TEST_EQUALS(scene.GetRootLayer(), defaultTask.GetSourceActor(), TEST_LOCATION); + + // Ensure stage size matches the scene size + auto stage = Stage::GetCurrent(); + Vector2 sceneSize = stage.GetSize(); + Viewport sceneViewport(0, 0, sceneSize.x, sceneSize.y); + DALI_TEST_EQUALS(stage.GetSize(), scene.GetSize(), TEST_LOCATION); + Viewport defaultViewport = defaultTask.GetViewport(); + DALI_TEST_EQUALS(defaultViewport, sceneViewport, TEST_LOCATION); + + Layer layer = scene.GetOverlayLayer(); + // There should be 2 task by default. + DALI_TEST_EQUALS(tasks.GetTaskCount(), 2u, TEST_LOCATION); + RenderTask overlayTask = tasks.GetTask(1u); + Viewport overlayViewport = defaultTask.GetViewport(); + DALI_TEST_EQUALS(defaultViewport, overlayViewport, TEST_LOCATION); + + // Resize the scene + Vector2 newSize(1000.0f, 2000.0f); + DALI_TEST_CHECK(stage.GetSize() != newSize); + scene.SurfaceResized(newSize.width, newSize.height); + Viewport newViewport(0, 0, newSize.x, newSize.y); + DALI_TEST_EQUALS(newViewport, defaultTask.GetViewport(), TEST_LOCATION); + DALI_TEST_EQUALS(newViewport, defaultTask.GetViewport(), TEST_LOCATION); + + END_TEST; +}