/*
- * Copyright (c) 2017 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.
*
*/
-#include <iostream>
#include <stdlib.h>
+#include <iostream>
// Need to override adaptor classes for toolkit test harness, so include
// test harness headers before dali headers.
#include <dali-toolkit-test-suite-utils.h>
-
#include <dali-toolkit/dali-toolkit.h>
-#include <dali/integration-api/events/key-event-integ.h>
-#include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/devel-api/controls/table-view/table-view.h>
+#include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/integration-api/events/key-event-integ.h>
+#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/events/wheel-event-integ.h>
using namespace Dali;
using namespace Dali::Toolkit;
test_return_value = TET_PASS;
}
-
namespace
{
-
const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
// Functors to test whether GetNextFocusableActor() method of CustomAlgorithmInterface is called when the keyboard focus is about to change
: mInterfaceVerified(interfaceVerified),
mCurrentFocusedActor(),
mProposedActorToFocus(),
- mDirection(Control::KeyboardFocus::LEFT)
+ mDirection(Control::KeyboardFocus::LEFT),
+ mDeviceName("")
{
}
- Actor GetNextFocusableActor(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocus::Direction direction)
+ Actor GetNextFocusableActor(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocus::Direction direction, const std::string& deviceName)
{
tet_infoline("Verifying CustomAlgorithm()");
mInterfaceVerified = true;
- mCurrentFocusedActor = currentFocusedActor;
+ mCurrentFocusedActor = currentFocusedActor;
mProposedActorToFocus = proposedActorToFocus;
- mDirection = direction;
+ mDirection = direction;
+ mDeviceName = deviceName;
return mProposedActorToFocus;
}
void Reset()
{
- mInterfaceVerified = false;
- mCurrentFocusedActor = Actor();
+ mInterfaceVerified = false;
+ mCurrentFocusedActor = Actor();
mProposedActorToFocus = Actor();
- mDirection = Control::KeyboardFocus::LEFT;
+ mDirection = Control::KeyboardFocus::LEFT;
+ mDeviceName = "";
}
- bool& mInterfaceVerified;
- Actor mCurrentFocusedActor;
- Actor mProposedActorToFocus;
+ bool& mInterfaceVerified;
+ Actor mCurrentFocusedActor;
+ Actor mProposedActorToFocus;
Control::KeyboardFocus::Direction mDirection;
+ std::string mDeviceName;
};
// Functors to test whether PreFocusChange signal is emitted when the keyboard focus is about to change
mSignalVerified = true;
- mCurrentFocusedActor = currentFocusedActor;
+ mCurrentFocusedActor = currentFocusedActor;
mProposedActorToFocus = proposedActorToFocus;
- mDirection = direction;
+ mDirection = direction;
return mProposedActorToFocus;
}
void Reset()
{
- mSignalVerified = false;
- mCurrentFocusedActor = Actor();
+ mSignalVerified = false;
+ mCurrentFocusedActor = Actor();
mProposedActorToFocus = Actor();
- mDirection = Control::KeyboardFocus::LEFT;
+ mDirection = Control::KeyboardFocus::LEFT;
}
- bool& mSignalVerified;
- Actor mCurrentFocusedActor;
- Actor mProposedActorToFocus;
+ bool& mSignalVerified;
+ Actor mCurrentFocusedActor;
+ Actor mProposedActorToFocus;
Control::KeyboardFocus::Direction mDirection;
};
}
mOriginalFocusedActor = originalFocusedActor;
- mCurrentFocusedActor = currentFocusedActor;
+ mCurrentFocusedActor = currentFocusedActor;
}
void Reset()
mSignalVerified = true;
mCurrentFocusedActor = currentFocusedActor;
- mForward = forward;
+ mForward = forward;
}
void Reset()
bool& mSignalVerified;
Actor mCurrentFocusedActor;
- bool mForward;
+ bool mForward;
};
// Functors to test whether focused actor activated signal is emitted when the focused actor is activated
Actor mActivatedActor;
};
+class KeyEventCallback : public Dali::ConnectionTracker
+{
+public:
+ /**
+ * Constructor
+ * @param[in] returnValue Set return value of KeyEvent callback.
+ * */
+ KeyEventCallback(bool consumed)
+ : mConsumed(consumed),
+ mIsCalled(false)
+ {
+ }
+
+ bool Callback(Control control, const KeyEvent& keyEvent)
+ {
+ mIsCalled = true;
+ return mConsumed;
+ }
+
+ void Callback(const KeyEvent& keyEvent)
+ {
+ mIsCalled = true;
+ }
+
+ bool mConsumed;
+ bool mIsCalled;
+};
+
+class WheelEventCallback : public Dali::ConnectionTracker
+{
+public:
+ /**
+ * Constructor
+ * @param[in] returnValue Set return value of WheelEvent callback.
+ * */
+ WheelEventCallback(bool consumed)
+ : mConsumed(consumed),
+ mIsCalled(false)
+ {
+ }
+
+ bool Callback(Actor actor, const WheelEvent& wheelEvent)
+ {
+ mIsCalled = true;
+ return mConsumed;
+ }
+
+ void Callback(const WheelEvent& wheelEvent)
+ {
+ mIsCalled = true;
+ }
+
+ bool mConsumed;
+ bool mIsCalled;
+};
+
// Used to connect to signals via the ConnectSignal Handle method
struct CallbackFunctor
{
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
KeyboardFocusManager manager;
// Create the first actor and add it to the stage
Actor first = Actor::New();
- first.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(first);
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
// Create the second actor and add it to the stage
Actor second = Actor::New();
- second.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(second);
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(second);
// Create the third actor but don't add it to the stage
Actor third = Actor::New();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
// Add the third actor to the stage
- Stage::GetCurrent().Add(third);
+ application.GetScene().Add(third);
// Check that it will fail to set focus on the third actor as it's not focusable
DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
// Make the third actor focusable
- third.SetKeyboardFocusable(true);
+ third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
// Check that the focus is successfully moved to the third actor
DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
KeyboardFocusManager manager = KeyboardFocusManager::Get();
DALI_TEST_CHECK(manager);
- bool preFocusChangeSignalVerified = false;
+ bool preFocusChangeSignalVerified = false;
PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
- manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+ manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
- bool focusChangedSignalVerified = false;
+ bool focusChangedSignalVerified = false;
FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
- manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+ manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
// Create the first actor and add it to the stage
Actor first = Actor::New();
- first.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(first);
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
// Create the second actor and add it to the stage
Actor second = Actor::New();
- second.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(second);
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(second);
// Move the focus to the right
DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
// Create a 2x2 table view and try to move focus inside it
- TableView tableView = TableView::New( 2, 2 );
- Stage::GetCurrent().Add(tableView);
+ TableView tableView = TableView::New(2, 2);
+ application.GetScene().Add(tableView);
// Create the third actor
Actor third = Actor::New();
- third.SetKeyboardFocusable(true);
+ third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
// Create the fourth actor
Actor fourth = Actor::New();
- fourth.SetKeyboardFocusable(true);
+ fourth.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
// Add the four children to table view
tableView.AddChild(first, TableView::CellPosition(0, 0));
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
KeyboardFocusManager manager = KeyboardFocusManager::Get();
DALI_TEST_CHECK(manager);
- bool preFocusChangeSignalVerified = false;
+ bool preFocusChangeSignalVerified = false;
PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
- manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+ manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
- bool focusChangedSignalVerified = false;
+ bool focusChangedSignalVerified = false;
FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
- manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+ manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
// Create the first actor and add it to the stage
Actor first = Actor::New();
- first.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(first);
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
// Create the second actor and add it to the stage
Actor second = Actor::New();
- second.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(second);
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(second);
// Move the focus to the right
DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
preFocusChangeCallback.Reset();
- bool customAlgorithmInterfaceVerified = false;
+ bool customAlgorithmInterfaceVerified = false;
+ std::string deviceName = "deviceName";
CustomAlgorithm customAlgorithm(customAlgorithmInterfaceVerified);
Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(manager, customAlgorithm);
// Move the focus towards right
- DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
+ DALI_TEST_CHECK(Toolkit::DevelKeyboardFocusManager::MoveFocus(manager, Control::KeyboardFocus::RIGHT, deviceName) == false);
// Because no layout control in the stage and the first actor is focused, it should invoke CustomAlgorithm
DALI_TEST_CHECK(customAlgorithm.mInterfaceVerified);
DALI_TEST_CHECK(customAlgorithm.mCurrentFocusedActor == Actor());
DALI_TEST_CHECK(customAlgorithm.mProposedActorToFocus == Actor());
DALI_TEST_CHECK(customAlgorithm.mDirection == Control::KeyboardFocus::RIGHT);
+ DALI_TEST_EQUALS(customAlgorithm.mDeviceName, deviceName, TEST_LOCATION );
customAlgorithm.Reset();
// Check that the focus is set on the first actor
focusChangedCallback.Reset();
// Move the focus towards right
- DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
+ DALI_TEST_CHECK(Toolkit::DevelKeyboardFocusManager::MoveFocus(manager, Control::KeyboardFocus::RIGHT, deviceName) == false);
// Because no layout control in the stage and the first actor is focused, it should invoke CustomAlgorithm
DALI_TEST_CHECK(customAlgorithm.mInterfaceVerified);
DALI_TEST_CHECK(customAlgorithm.mCurrentFocusedActor == first);
DALI_TEST_CHECK(customAlgorithm.mProposedActorToFocus == Actor());
DALI_TEST_CHECK(customAlgorithm.mDirection == Control::KeyboardFocus::RIGHT);
+ DALI_TEST_EQUALS(customAlgorithm.mDeviceName, deviceName, TEST_LOCATION );
customAlgorithm.Reset();
// Check that the focus is set on the second actor
focusChangedCallback.Reset();
// Move the focus towards up
- DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == false);
+ DALI_TEST_CHECK(Toolkit::DevelKeyboardFocusManager::MoveFocus(manager, Control::KeyboardFocus::UP, deviceName) == false);
// Because no layout control in the stage and no actor is focused, it should invoke CustomAlgorithm
DALI_TEST_CHECK(customAlgorithm.mInterfaceVerified);
DALI_TEST_CHECK(customAlgorithm.mCurrentFocusedActor == second);
DALI_TEST_CHECK(customAlgorithm.mProposedActorToFocus == Actor());
DALI_TEST_CHECK(customAlgorithm.mDirection == Control::KeyboardFocus::UP);
+ DALI_TEST_EQUALS(customAlgorithm.mDeviceName, deviceName, TEST_LOCATION );
customAlgorithm.Reset();
DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
KeyboardFocusManager manager = KeyboardFocusManager::Get();
DALI_TEST_CHECK(manager);
- bool focusChangedSignalVerified = false;
+ bool focusChangedSignalVerified = false;
FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
- manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+ manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
PushButton button1 = PushButton::New();
PushButton button2 = PushButton::New();
- button1.SetKeyboardFocusable(true);
- button2.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(button1);
- Stage::GetCurrent().Add(button2);
+ button1.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ button2.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(button1);
+ application.GetScene().Add(button2);
// Set the focus to the button1
DALI_TEST_CHECK(manager.SetCurrentFocusActor(button1) == true);
focusChangedCallback.Reset();
// set the navigation properties of button1
- button1.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetId()));
- button1.SetProperty(Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetId()));
- button1.SetProperty(Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetId()));
- button1.SetProperty(Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetId()));
+ button1.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty<int>(Actor::Property::ID)));
+ button1.SetProperty(Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty<int>(Actor::Property::ID)));
+ button1.SetProperty(Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty<int>(Actor::Property::ID)));
+ button1.SetProperty(Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty<int>(Actor::Property::ID)));
+ button1.SetProperty(Toolkit::DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty< int >( Actor::Property::ID)));
+ button1.SetProperty(Toolkit::DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty< int >( Actor::Property::ID)));
// set the navigation properties of button2
- button2.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
- button2.SetProperty(Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
- button2.SetProperty(Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
- button2.SetProperty(Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
+ button2.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
+ button2.SetProperty(Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
+ button2.SetProperty(Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
+ button2.SetProperty(Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
+ button2.SetProperty(Toolkit::DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty< int >( Actor::Property::ID)));
+ button2.SetProperty(Toolkit::DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty< int >( Actor::Property::ID)));
// Move the focus towards left
DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
// Confirm whether focus is moved to button2
- DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
// Confirm whether focus is moved to button1
- DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == true);
// Confirm whether focus is moved to button2
- DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::DOWN) == true);
// Confirm whether focus is moved to button1
+ DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards clockwise
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::CLOCKWISE) == true);
+
+ // Confirm whether focus is moved to button2
+ DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards clockwise
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::COUNTER_CLOCKWISE) == true);
+
+ // Confirm whether focus is moved to button1
DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
focusChangedCallback.Reset();
// Create a 1x1 table view and try to move focus inside it
- TableView tableView = TableView::New( 1, 1 );
- Stage::GetCurrent().Add(tableView);
+ TableView tableView = TableView::New(1, 1);
+ application.GetScene().Add(tableView);
PushButton button = PushButton::New();
- button.SetKeyboardFocusable(true);
+ button.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
tableView.AddChild(button, TableView::CellPosition(0, 0));
// set the navigation properties of button3
- button.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
+ button.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
// Set the focus to the button
DALI_TEST_CHECK(manager.SetCurrentFocusActor(button) == true);
DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
// Confirm whether focus is moved to button1
- DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
// Create the first actor and add it to the stage
Actor first = Actor::New();
- first.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(first);
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
// Create the second actor and add it to the stage
Actor second = Actor::New();
- second.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(second);
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(second);
// Check that the focus is set on the first actor
DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
// Create an actor with two child actors and add it to the stage
Actor parent = Actor::New();
- Actor child = Actor::New();
+ Actor child = Actor::New();
parent.Add(child);
- Stage::GetCurrent().Add(parent);
+ application.GetScene().Add(parent);
// Create three actors and add them as the children of the first child actor
Actor grandChild = Actor::New();
END_TEST;
}
-
int UtcDaliKeyboardFocusManagerSignalFocusedActorActivated(void)
{
ToolkitTestApplication application;
KeyboardFocusManager manager = KeyboardFocusManager::Get();
DALI_TEST_CHECK(manager);
- bool focusedActorActivatedSignalVerified = false;
+ bool focusedActorActivatedSignalVerified = false;
FocusedActorActivatedCallback focusedActorActivatedCallback(focusedActorActivatedSignalVerified);
- manager.FocusedActorEnterKeySignal().Connect( &focusedActorActivatedCallback, &FocusedActorActivatedCallback::Callback );
+ manager.FocusedActorEnterKeySignal().Connect(&focusedActorActivatedCallback, &FocusedActorActivatedCallback::Callback);
- Integration::KeyEvent returnEvent( "Return", "", 0, 0, 0, Integration::KeyEvent::Up, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+ Integration::KeyEvent returnEvent("Return", "", "", 0, 0, 0, Integration::KeyEvent::UP, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
// Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
// It makes mIsFocusIndicatorEnabled true
// Create the first button and add it to the stage
PushButton firstPushButton = PushButton::New();
- firstPushButton.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(firstPushButton);
+ firstPushButton.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(firstPushButton);
// Create the second button and add it to the stage
PushButton secondPushButton = PushButton::New();
- secondPushButton.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(secondPushButton);
+ secondPushButton.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(secondPushButton);
// Check that the focus is set on the first button
DALI_TEST_CHECK(manager.SetCurrentFocusActor(firstPushButton) == true);
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
KeyboardFocusManager manager = KeyboardFocusManager::Get();
DALI_TEST_CHECK(manager);
- bool focusGroupChangedSignalVerified = false;
+ bool focusGroupChangedSignalVerified = false;
FocusGroupChangedCallback focusGroupChangedCallback(focusGroupChangedSignalVerified);
- manager.FocusGroupChangedSignal().Connect( &focusGroupChangedCallback, &FocusGroupChangedCallback::Callback );
+ manager.FocusGroupChangedSignal().Connect(&focusGroupChangedCallback, &FocusGroupChangedCallback::Callback);
- Integration::KeyEvent tabEvent( "Tab", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- Integration::KeyEvent shiftTabEvent( "Tab", "", 0, 1, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+ Integration::KeyEvent tabEvent("Tab", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ Integration::KeyEvent shiftTabEvent("Tab", "", "", 0, 1, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
// Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
// It makes mIsFocusIndicatorEnabled true
ToolkitTestApplication application;
KeyboardFocusManager manager = KeyboardFocusManager::Get();
- DALI_TEST_CHECK( manager );
+ DALI_TEST_CHECK(manager);
ConnectionTracker* testTracker = new ConnectionTracker();
- DALI_TEST_EQUALS( true, manager.ConnectSignal( testTracker, "keyboardPreFocusChange", CallbackFunctor() ), TEST_LOCATION );
- DALI_TEST_EQUALS( true, manager.ConnectSignal( testTracker, "keyboardFocusChanged", CallbackFunctor() ), TEST_LOCATION );
- DALI_TEST_EQUALS( true, manager.ConnectSignal( testTracker, "keyboardFocusGroupChanged", CallbackFunctor() ), TEST_LOCATION );
- DALI_TEST_EQUALS( true, manager.ConnectSignal( testTracker, "keyboardFocusedActorEnterKey", CallbackFunctor() ), TEST_LOCATION );
+ DALI_TEST_EQUALS(true, manager.ConnectSignal(testTracker, "keyboardPreFocusChange", CallbackFunctor()), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, manager.ConnectSignal(testTracker, "keyboardFocusChanged", CallbackFunctor()), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, manager.ConnectSignal(testTracker, "keyboardFocusGroupChanged", CallbackFunctor()), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, manager.ConnectSignal(testTracker, "keyboardFocusedActorEnterKey", CallbackFunctor()), TEST_LOCATION);
END_TEST;
}
// Create the first actor and add it to the stage
Actor first = Actor::New();
- first.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(first);
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
// Create the second actor and add it to the stage
Actor second = Actor::New();
- second.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(second);
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(second);
// Create the third actor and add it to the stage
Actor third = Actor::New();
- third.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(third);
+ third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(third);
// Create the fourth actor and add it to the stage
Actor fourth = Actor::New();
- fourth.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(fourth);
+ fourth.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(fourth);
// Check that the focus is set on the second actor
DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
// Make history stack full
- for(int i = 0 ; i < 31 ; i ++)
+ for(int i = 0; i < 31; i++)
{
Actor actor = Actor::New();
- actor.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(actor);
+ actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(actor);
manager.SetCurrentFocusActor(actor);
}
- for(int i = 0 ; i < 31 ; i ++)
+ for(int i = 0; i < 31; i++)
{
manager.MoveFocusBackward();
}
KeyboardFocusManager manager = KeyboardFocusManager::Get();
DALI_TEST_CHECK(manager);
- bool preFocusChangeSignalVerified = false;
+ bool preFocusChangeSignalVerified = false;
PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
- manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+ manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
- bool focusChangedSignalVerified = false;
+ bool focusChangedSignalVerified = false;
FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
- manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+ manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
- Integration::KeyEvent leftEvent( "Left", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- Integration::KeyEvent rightEvent( "Right", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- Integration::KeyEvent upEvent( "Up", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- Integration::KeyEvent downEvent( "Down", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- Integration::KeyEvent pageUpEvent( "Prior", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- Integration::KeyEvent pageDownEvent( "Next", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+ Integration::KeyEvent leftEvent("Left", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ Integration::KeyEvent rightEvent("Right", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ Integration::KeyEvent upEvent("Up", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ Integration::KeyEvent downEvent("Down", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ Integration::KeyEvent pageUpEvent("Prior", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ Integration::KeyEvent pageDownEvent("Next", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
// Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
// It makes mIsFocusIndicatorEnabled true
application.ProcessEvent(leftEvent);
// Create a 2x2 table view and try to move focus inside it
- TableView tableView = TableView::New( 2, 2 );
- Stage::GetCurrent().Add(tableView);
+ TableView tableView = TableView::New(2, 2);
+ application.GetScene().Add(tableView);
// Create the first actor
Actor first = Actor::New();
- first.SetKeyboardFocusable(true);
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
// Create the second actor
Actor second = Actor::New();
- second.SetKeyboardFocusable(true);
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
// Create the third actor
Actor third = Actor::New();
- third.SetKeyboardFocusable(true);
+ third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
// Create the fourth actor
Actor fourth = Actor::New();
- fourth.SetKeyboardFocusable(true);
+ fourth.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
// Add the four children to table view
tableView.AddChild(first, TableView::CellPosition(0, 0));
KeyboardFocusManager manager = KeyboardFocusManager::Get();
DALI_TEST_CHECK(manager);
- bool preFocusChangeSignalVerified = false;
+ bool preFocusChangeSignalVerified = false;
PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
- manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+ manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
- Integration::KeyEvent spaceEvent( "space", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+ Integration::KeyEvent spaceEvent("space", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
// Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
// It makes mIsFocusIndicatorEnabled true
END_TEST;
}
-
-
int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
{
ToolkitTestApplication application;
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
KeyboardFocusManager manager = KeyboardFocusManager::Get();
DALI_TEST_CHECK(manager);
- bool preFocusChangeSignalVerified = false;
+ bool preFocusChangeSignalVerified = false;
PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
- manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+ manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
- bool focusChangedSignalVerified = false;
+ bool focusChangedSignalVerified = false;
FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
- manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+ manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
// Create the first actor and add it to the stage
Control first = Control::New();
- first.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(first);
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
// Create the second actor and add it to the stage
Control second = Control::New();
- second.SetKeyboardFocusable(true);
- Stage::GetCurrent().Add(second);
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(second);
// Move the focus to the right
DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
focusChangedCallback.Reset();
// Move the focus towards right
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
focusChangedCallback.Reset();
// Move the focus towards up
DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
// Create a 2x2 table view and try to move focus inside it
- TableView tableView = TableView::New( 2, 2 );
- Stage::GetCurrent().Add(tableView);
+ TableView tableView = TableView::New(2, 2);
+ application.GetScene().Add(tableView);
// Create the third actor
Control third = Control::New();
- third.SetKeyboardFocusable(true);
+ third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
// Create the fourth actor
Control fourth = Control::New();
- fourth.SetKeyboardFocusable(true);
+ fourth.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
// Add the four children to table view
tableView.AddChild(first, TableView::CellPosition(0, 0));
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
- DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
focusChangedCallback.Reset();
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
focusChangedCallback.Reset();
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == fourth);
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
focusChangedCallback.Reset();
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == fourth);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == third);
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
- DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
focusChangedCallback.Reset();
DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == third);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
- DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
focusChangedCallback.Reset();
// Move the focus towards left. The focus move will fail as no way to move it upwards
DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == first);
DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::LEFT);
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
- DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
preFocusChangeCallback.Reset();
DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == fourth);
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
focusChangedCallback.Reset();
// Clear the focus
manager.ClearFocus();
- DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
- DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-
+ DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+ DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
END_TEST;
}
{
ToolkitTestApplication application;
- tet_infoline( "Ensure we cannot set an actor to be focused if it is not staged and that we do not retrieve an actor if it has been unstaged" );
+ tet_infoline("Ensure we cannot set an actor to be focused if it is not staged and that we do not retrieve an actor if it has been unstaged");
KeyboardFocusManager manager = KeyboardFocusManager::Get();
- DALI_TEST_CHECK( ! manager.GetCurrentFocusActor() );
+ DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
Actor actor = Actor::New();
- actor.SetKeyboardFocusable( true );
+ actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
- tet_infoline( "Attempt to set unstaged actor, no actor should be returned from KeyboardFocusManager" );
- manager.SetCurrentFocusActor( actor );
- DALI_TEST_CHECK( ! manager.GetCurrentFocusActor() );
+ tet_infoline("Attempt to set unstaged actor, no actor should be returned from KeyboardFocusManager");
+ manager.SetCurrentFocusActor(actor);
+ DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
- tet_infoline( "Add actor to stage and attempt to set, our actor should be returned from KeyboardFocusManager" );
- Stage::GetCurrent().Add( actor );
- manager.SetCurrentFocusActor( actor );
- DALI_TEST_CHECK( manager.GetCurrentFocusActor() == actor );
+ tet_infoline("Add actor to stage and attempt to set, our actor should be returned from KeyboardFocusManager");
+ application.GetScene().Add(actor);
+ manager.SetCurrentFocusActor(actor);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == actor);
- tet_infoline( "Remove actor from stage and attempt to retrieve, no actor should be returned from KeyboardFocusManager" );
+ tet_infoline("Remove actor from stage and attempt to retrieve, no actor should be returned from KeyboardFocusManager");
actor.Unparent();
- DALI_TEST_CHECK( ! manager.GetCurrentFocusActor() );
+ DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
END_TEST;
}
{
ToolkitTestApplication application;
- tet_infoline( "Ensure we cannot set an actor to be focused if it is not staged and that we do not retrieve an actor if it has been unstaged" );
+ tet_infoline("Ensure we cannot set an actor to be focused if it is not staged and that we do not retrieve an actor if it has been unstaged");
KeyboardFocusManager manager = KeyboardFocusManager::Get();
- DALI_TEST_CHECK( ! manager.GetCurrentFocusActor() );
+ DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
Actor actor = Actor::New();
- actor.SetKeyboardFocusable( true );
- Stage::GetCurrent().Add( actor );
- manager.SetCurrentFocusActor( actor );
+ actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(actor);
+ manager.SetCurrentFocusActor(actor);
// Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
// It makes mIsFocusIndicatorEnabled true and add focus indicator to focused actor.
- Integration::KeyEvent rightEvent( "Right", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+ Integration::KeyEvent rightEvent("Right", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
application.ProcessEvent(rightEvent);
Actor indicatorActor = manager.GetFocusIndicatorActor();
- tet_infoline( "Indicator is added to focused actor" );
- DALI_TEST_CHECK( actor == indicatorActor.GetParent() );
+ tet_infoline("Indicator is added to focused actor");
+ DALI_TEST_CHECK(actor == indicatorActor.GetParent());
Dali::Toolkit::DevelKeyboardFocusManager::EnableFocusIndicator(manager, false);
- DALI_TEST_CHECK( !Dali::Toolkit::DevelKeyboardFocusManager::IsFocusIndicatorEnabled(manager) );
+ DALI_TEST_CHECK(!Dali::Toolkit::DevelKeyboardFocusManager::IsFocusIndicatorEnabled(manager));
+
+ tet_infoline("Indicator is removed from focused actor because mUseFocusIndicator is false");
+ DALI_TEST_CHECK(!indicatorActor.GetParent());
+
+ END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerCheckConsumedKeyEvent(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline("Ensure Window can't receive KeyEvent when Control already consumed it");
+ Dali::Integration::Scene scene = application.GetScene();
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
+
+ // Create the first actor and add it to the stage
+ Control control = Control::New();
+ control.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ scene.Add(control);
+
+ KeyEventCallback controlCallback(true);
+ control.KeyEventSignal().Connect(&controlCallback, &KeyEventCallback::Callback);
+
+ KeyEventCallback sceneCallback(false);
+ scene.KeyEventSignal().Connect(&sceneCallback, &KeyEventCallback::Callback);
+
+ manager.SetCurrentFocusActor(control);
+
+ // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
+ // It makes mIsFocusIndicatorEnabled true and add focus indicator to focused actor.
+ Integration::KeyEvent event1("Right", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event1);
+
+ DALI_TEST_CHECK(controlCallback.mIsCalled);
+ DALI_TEST_CHECK(!sceneCallback.mIsCalled);
+
+ END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerFocusPerWindow(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline("Ensure Memory focus actors for each window ");
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
+
+ Window firstWindow = Window::New(PositionSize(0, 0, 300, 500), "", false);
+ DALI_TEST_CHECK(firstWindow);
+ Control first = Control::New();
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ firstWindow.Add(first);
+
+ Window secondWindow = Window::New(PositionSize(0, 0, 400, 600), "", false);
+ DALI_TEST_CHECK(secondWindow);
+ Control second = Control::New();
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ secondWindow.Add(second);
+
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+ firstWindow.Raise();
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ secondWindow.Remove(second);
+ secondWindow.Raise();
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() != second);
+
+ secondWindow.Reset();
+ END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus");
- tet_infoline( "Indicator is removed from focused actor because mUseFocusIndicator is false" );
- DALI_TEST_CHECK( !indicatorActor.GetParent() );
+ // Register Type
+ TypeInfo type;
+ type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+ DALI_TEST_CHECK(type);
+ BaseHandle handle = type.CreateInstance();
+ DALI_TEST_CHECK(handle);
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ bool focusChangedSignalVerified = false;
+ FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
+ manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
+
+ PushButton button1 = PushButton::New();
+ PushButton button2 = PushButton::New();
+ PushButton button3 = PushButton::New();
+ PushButton button4 = PushButton::New();
+ PushButton button5 = PushButton::New();
+
+ button1.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+ button2.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+ button3.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+ button4.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+ button5.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+
+ button1.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ button2.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ button3.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ button4.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ button5.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+ application.GetScene().Add(button1);
+ application.GetScene().Add(button2);
+ application.GetScene().Add(button3);
+ button5.Add(button4);
+ application.GetScene().Add(button5);
+
+ // set position
+ // button1 -- button2
+ // | |
+ // | button5|
+ // button3 -- button4
+ button1.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
+ button2.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 0.0f));
+ button3.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 100.0f));
+ button4.SetProperty(Actor::Property::POSITION, Vector2(40.0f, 40.0f));
+ button5.SetProperty(Actor::Property::POSITION, Vector2(60.0f, 60.0f));
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ // Set the focus to the button1
+ // [button1] -- button2
+ // | |
+ // | button5|
+ // button3 -- button4
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(button1) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == button1);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+ focusChangedCallback.Reset();
+
+ // without set the navigation properties, but we can focus move
+ // enable the default algorithm
+ Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(manager, true);
+ DALI_TEST_CHECK(Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(manager));
+
+ // Move the focus towards right
+ // button1 -- [button2]
+ // | |
+ // | button5|
+ // button3 -- button4
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+ // Confirm whether focus is moved to button2
+ DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards down
+ // button1 -- button2
+ // | |
+ // | [button5]|
+ // button3 -- button4
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::DOWN) == true);
+
+ // Confirm whether focus is moved to button5
+ DALI_TEST_EQUALS(button5.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button5);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards right
+ // button1 -- button2
+ // | |
+ // | button5|
+ // button3 -- [button4]
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+ // Confirm whether focus is moved to button4
+ DALI_TEST_EQUALS(button4.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button5);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button4);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards left
+ // button1 -- button2
+ // | |
+ // | [button5]|
+ // button3 -- button4
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+
+ // Confirm whether focus is moved to button5
+ DALI_TEST_EQUALS(button5.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button4);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button5);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards left
+ // button1 -- button2
+ // | |
+ // | button5|
+ //[button3] -- button4
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+
+ // Confirm whether focus is moved to button3
+ DALI_TEST_EQUALS(button3.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button5);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button3);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards right
+ // button1 -- button2
+ // | |
+ // | [button5]|
+ // button3 -- button4
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+ // Confirm whether focus is moved to button5
+ DALI_TEST_EQUALS(button5.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button3);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button5);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards left
+ // button1 -- button2
+ // | |
+ // | button5|
+ //[button3] -- button4
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+
+ // Confirm whether focus is moved to button3
+ DALI_TEST_EQUALS(button3.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button5);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button3);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards up
+ //[button1]-- button2
+ // | |
+ // | button5|
+ // button3 -- button4
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == true);
+
+ // Confirm whether focus is moved to button1
+ DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button3);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+ focusChangedCallback.Reset();
+
+ // Move the focus towards left. The focus move will fail as no way to move it upwards
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == false);
+
+ // Move the focus toward page up/down. The focus move will fail as invalid direction.
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::PAGE_UP) == false);
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::PAGE_DOWN) == false);
+ focusChangedCallback.Reset();
END_TEST;
}
+int UtcDaliKeyboardFocusManagerSetAndGetCurrentFocusActorInTouchMode(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerSetAndGetCurrentFocusActorInTouchMode");
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ // Create the first actor and add it to the stage
+ Actor first = Actor::New();
+ first.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+ first.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
+ first.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ first.SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, true);
+ application.GetScene().Add(first);
+
+ // Create the second actor and add it to the stage
+ Actor second = Actor::New();
+ second.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+ second.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 0.0f));
+ second.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(second);
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ // Check that no actor is being focused yet.
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+ // Check that it will fail to set focus on an invalid actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(Actor()) == false);
+
+ Dali::Integration::TouchEvent event1 = Dali::Integration::TouchEvent();
+ Dali::Integration::Point pointDown1;
+ pointDown1.SetState(PointState::DOWN);
+ pointDown1.SetDeviceId(1);
+ // touch first actor
+ pointDown1.SetScreenPosition(Vector2(10.0f, 10.0f));
+ event1.AddPoint(pointDown1);
+ application.ProcessEvent(event1);
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ // Check that the focus is successfully to the first actor
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+ Dali::Integration::TouchEvent event2 = Dali::Integration::TouchEvent();
+ Dali::Integration::Point pointDown2;
+ pointDown2.SetState(PointState::DOWN);
+ pointDown2.SetDeviceId(1);
+ // touch second actor
+ pointDown2.SetScreenPosition(Vector2(110.0f, 10.0f));
+ event2.AddPoint(pointDown2);
+ application.ProcessEvent(event2);
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ // Since no focus has been moved, the current focus actor is the same.
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ // Make the second actor focusableInTouchMode
+ second.SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, true);
+
+ // touch second actor
+ application.ProcessEvent(event2);
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ // Check that the focus is successfully to the second actor
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+
+ END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerEnableDefaultAlgorithm(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerEnableDefaultAlgorithm");
+
+ // Register Type
+ TypeInfo type;
+ type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+ DALI_TEST_CHECK(type);
+ BaseHandle handle = type.CreateInstance();
+ DALI_TEST_CHECK(handle);
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ bool focusChangedSignalVerified = false;
+ FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
+ manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
+
+ PushButton button1 = PushButton::New();
+ PushButton button2 = PushButton::New();
+
+ button1.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+ button2.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+
+ button1.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ button2.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+ application.GetScene().Add(button1);
+ application.GetScene().Add(button2);
+
+ // set position
+ // button1 -- button2
+ button1.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
+ button2.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 0.0f));
+ button1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ button2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ // Set the focus to the button1
+ // [button1] -- button2
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(button1) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == button1);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+ focusChangedCallback.Reset();
+
+ // without set the navigation properties, but we can focus move
+ // enable the default algorithm
+ Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(manager, true);
+ DALI_TEST_CHECK(Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(manager));
+
+ // Move the focus towards right
+ // button1 -- [button2]
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+ // Confirm whether focus is moved to button2
+ DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
+ focusChangedCallback.Reset();
+
+ // disable the default algorithm
+ Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(manager, false);
+ DALI_TEST_CHECK(!Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(manager));
+
+ // Move the focus towards left, The focus move will fail because the default algorithm is disabled.
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == false);
+
+ // enable the default algorithm
+ Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(manager, true);
+ DALI_TEST_CHECK(Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(manager));
+
+ // Move the focus towards left, The focus move will success because the default algorithm is enabled.
+ // [button1] -- button2
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+ // Confirm whether focus is moved to button1
+ DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+ focusChangedCallback.Reset();
+
+ // Clears focus.
+ manager.ClearFocus();
+ // There is no actor focused.
+ // button1 -- button2
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+ // Move the focus towards right, The focus is on the actor closest to the top left of the window.
+ // [button1] -- button2
+ DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+ // Confirm whether focus is moved to button1
+ DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+ focusChangedCallback.Reset();
+
+
+ END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerWithKeyboardFocusableChildren(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerWithKeyboardFocusableChildren");
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ // Create the first actor and add it to the stage
+ Actor first = Actor::New();
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
+
+ // Create the second actor and add it to the first actor.
+ Actor second = Actor::New();
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ first.Add(second);
+
+ // Check that no actor is being focused yet.
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+ // Check that the focus is set on the first actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ // Set KeyboardFocusableChildren false.
+ first.SetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, false);
+
+ // Check that it will fail to set focus on the second actor as it's not focusable
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == false);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ // Set KeyboardFocusableChildren true.
+ first.SetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, true);
+
+ // Check that the focus is set on the second actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+
+ END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerCheckWheelEvent(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline("UtcDaliKeyboardFocusManagerCheckWheelEvent");
+ Dali::Integration::Scene scene = application.GetScene();
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
+
+ // Create the first actor and add it to the stage
+ Actor parent = Actor::New();
+ parent.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+ Actor child = Actor::New();
+ child.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+ parent.Add(child);
+ scene.Add(parent);
+
+ WheelEventCallback childCallback(false);
+ child.WheelEventSignal().Connect(&childCallback, &WheelEventCallback::Callback);
+
+ WheelEventCallback parentCallback(true);
+ parent.WheelEventSignal().Connect(&parentCallback, &WheelEventCallback::Callback);
+
+ WheelEventCallback sceneCallback(false);
+ scene.WheelEventSignal().Connect(&sceneCallback, &WheelEventCallback::Callback);
+
+ manager.SetCurrentFocusActor(child);
+
+ // Emit custom wheel event is comming to KeyboardFocusManager
+ Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
+ application.ProcessEvent(event);
+
+ DALI_TEST_CHECK(childCallback.mIsCalled);
+ DALI_TEST_CHECK(parentCallback.mIsCalled);
+ DALI_TEST_CHECK(!sceneCallback.mIsCalled);
+
+ END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerChangeFocusDirectionByCustomWheelEvent(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerChangeFocusDirectionByCustomWheelEvent");
+ Dali::Integration::Scene scene = application.GetScene();
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ bool focusChangedSignalVerified = false;
+ FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
+ manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+
+ Integration::WheelEvent clockwiseEvent(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
+ Integration::WheelEvent counterClockwiseEvent(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1100u);
+
+ // Create the first button
+ PushButton first = PushButton::New();
+ first.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE,true);
+ scene.Add(first);
+
+ // Create the second button
+ PushButton second = PushButton::New();
+ second.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE,true);
+ scene.Add(second);
+
+ // set the navigation properties
+ first.SetProperty(Toolkit::DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)second.GetProperty< int >( Actor::Property::ID )));
+ second.SetProperty(Toolkit::DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)first.GetProperty< int >( Actor::Property::ID )));
+
+ // Set the focus to the first actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
+ focusChangedCallback.Reset();
+
+ // Send the clockwise wheel event to move the focus towards clockwise
+ application.ProcessEvent(clockwiseEvent);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
+ focusChangedCallback.Reset();
+
+ // Send the counter clockwise wheel event to move the focus towards count clockwise
+ application.ProcessEvent(counterClockwiseEvent);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+ DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+ DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
+ DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
+ focusChangedCallback.Reset();
+
+ // Clear the focus
+ manager.ClearFocus();
+
+ END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerWithUserInteractionEnabled(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerWithUserInteractionEnabled");
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ // Create the first control and add it to the stage
+ Control first = Control::New();
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
+
+ // Create the second control and add it to the first control.
+ Control second = Control::New();
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ first.Add(second);
+
+ // Check that no actor is being focused yet.
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+ // Check that the focus is set on the first actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ // Set USER_INTERACTION_ENABLED false.
+ second.SetProperty(DevelActor::Property::USER_INTERACTION_ENABLED, false);
+
+ // Check that it will fail to set focus on the second actor as it's not userInteractionEnabled
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == false);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ // Set KeyboardFocusableChildren true.
+ second.SetProperty(DevelActor::Property::USER_INTERACTION_ENABLED, true);
+
+ // Check that the focus is set on the second actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+
+ // If the currently focused actor becomes USER_INTERACTION_ENABLED false, it loses focus.
+ second.SetProperty(DevelActor::Property::USER_INTERACTION_ENABLED, false);
+
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+
+ END_TEST;
+}
+
+
+int UtcDaliKeyboardFocusManagerWithHide(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerWithHide");
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ // Create the first control and add it to the stage
+ Control first = Control::New();
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
+
+ // Create the second control and add it to the first control.
+ Control second = Control::New();
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ first.Add(second);
+
+
+ // flush the queue and render once
+ application.SendNotification();
+ application.Render();
+
+ // Check that no actor is being focused yet.
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+ // Check that the focus is set on the actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ // If the currently focused actor becomes VISIBLE false, it loses focus.
+ first.SetProperty(Actor::Property::VISIBLE, false);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+ first.SetProperty(Actor::Property::VISIBLE, true);
+ // Check that the focus is set on the actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+
+ // If the currently focused actor becomes VISIBLE false, When the parent is hidden, the child also loses focus.
+ first.SetProperty(Actor::Property::VISIBLE, false);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+
+ END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerWithVisible(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline(" UtcDaliKeyboardFocusManagerWithVisible");
+
+ KeyboardFocusManager manager = KeyboardFocusManager::Get();
+ DALI_TEST_CHECK(manager);
+
+ // Create the first actor and add it to the stage
+ Actor first = Actor::New();
+ first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ application.GetScene().Add(first);
+
+ // Create the second actor and add it to the first actor.
+ Actor second = Actor::New();
+ second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ first.Add(second);
+
+ // Check that no actor is being focused yet.
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+ // Check that the focus is set on the first actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ // Set visible false.
+ first.SetProperty(Actor::Property::VISIBLE, false);
+
+ // Check that it will fail to set focus on the second actor as it's not focusable
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == false);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+ // Set visible true.
+ first.SetProperty(Actor::Property::VISIBLE, true);
+
+ // Check that the focus is set on the second actor
+ DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+ DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+
+ END_TEST;
+}
\ No newline at end of file