utc-Dali-ControlImpl.cpp
utc-Dali-DefaultControls.cpp
utc-Dali-DissolveEffect.cpp
- utc-Dali-FocusManager.cpp
+ utc-Dali-AccessibilityFocusManager.cpp
utc-Dali-IrisEffect.cpp
utc-Dali-ItemLayout.cpp
utc-Dali-ItemView.cpp
using namespace Toolkit;
-void utc_dali_toolkit_focus_manager_startup(void)
+void utc_dali_toolkit_accessibility_focus_manager_startup(void)
{
test_return_value = TET_UNDEF;
}
-void utc_dali_toolkit_focus_manager_cleanup(void)
+void utc_dali_toolkit_accessibility_focus_manager_cleanup(void)
{
test_return_value = TET_PASS;
}
FocusOvershotCallback(bool& signalReceived)
: mSignalVerified(signalReceived),
mCurrentFocusedActor(),
- mFocusOvershotDirection(Toolkit::FocusManager::OVERSHOT_NEXT)
+ mFocusOvershotDirection(Toolkit::AccessibilityFocusManager::OVERSHOT_NEXT)
{
}
- void Callback(Actor currentFocusedActor, Toolkit::FocusManager::FocusOvershotDirection direction)
+ void Callback(Actor currentFocusedActor, Toolkit::AccessibilityFocusManager::FocusOvershotDirection direction)
{
tet_infoline("Verifying FocusOvershotCallback()");
bool& mSignalVerified;
Actor mCurrentFocusedActor;
- Toolkit::FocusManager::FocusOvershotDirection mFocusOvershotDirection;
+ Toolkit::AccessibilityFocusManager::FocusOvershotDirection mFocusOvershotDirection;
};
// Functor to test whether focused actor activated signal is emitted.
} // namespace
-int UtcDaliFocusManagerGet(void)
+int UtcDaliAccessibilityFocusManagerGet(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerGet");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerGet");
- FocusManager manager;
+ AccessibilityFocusManager manager;
//Ensure object is created by checking if it's registered
ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
gObjectCreatedCallBackCalled = false;
registry.ObjectCreatedSignal().Connect( &TestCallback );
{
- manager = FocusManager::Get();
+ manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
}
DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
- FocusManager newManager = FocusManager::Get();
+ AccessibilityFocusManager newManager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(newManager);
// Check that focus manager is a singleton
END_TEST;
}
-int UtcDaliFocusManagerSetAndGetAccessibilityAttribute(void)
+int UtcDaliAccessibilityFocusManagerSetAndGetAccessibilityAttribute(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerSetAndGetAccessibilityAttribute");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerSetAndGetAccessibilityAttribute");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
Actor actor = Actor::New();
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, FocusManager::ACCESSIBILITY_LABEL) == "");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "");
- manager.SetAccessibilityAttribute(actor, FocusManager::ACCESSIBILITY_LABEL, "Description");
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, FocusManager::ACCESSIBILITY_LABEL) == "Description");
+ manager.SetAccessibilityAttribute(actor, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "Description");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "Description");
- manager.SetAccessibilityAttribute(actor, FocusManager::ACCESSIBILITY_LABEL, "New description");
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, FocusManager::ACCESSIBILITY_LABEL) == "New description");
+ manager.SetAccessibilityAttribute(actor, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "New description");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "New description");
END_TEST;
}
-int UtcDaliFocusManagerSetAndGetFocusOrder(void)
+int UtcDaliAccessibilityFocusManagerSetAndGetFocusOrder(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerSetAndGetFocusOrder");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerSetAndGetFocusOrder");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
Actor first = Actor::New();
// Set the focus order and description for the first actor
manager.SetFocusOrder(first, 1);
- manager.SetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL, "first");
+ manager.SetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "first");
DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Set the focus order and description for the second actor
manager.SetFocusOrder(second, 2);
- manager.SetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL, "second");
+ manager.SetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "second");
DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL) == "second");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "second");
// check that the focus order of the first actor is changed
manager.SetFocusOrder(first, 2);
DALI_TEST_CHECK(manager.GetFocusOrder(first) == 2);
// make sure the change of focus order doesn't affect the actor's description
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// check that the focus order of the second actor is increased to 3
DALI_TEST_CHECK(manager.GetFocusOrder(second) == 3);
// make sure the change of focus order doesn't affect the actor's description
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL) == "second");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "second");
// check that the focus order of the second actor is changed to 1
manager.SetFocusOrder(second, 1);
DALI_TEST_CHECK(manager.GetFocusOrder(second) == 1);
// make sure the change of focus order doesn't affect the actor's description
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL) == "second");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "second");
// Set the focus order and description for the third actor
Actor third = Actor::New();
manager.SetFocusOrder(third, 1);
- manager.SetAccessibilityAttribute(third, FocusManager::ACCESSIBILITY_LABEL, "third");
+ manager.SetAccessibilityAttribute(third, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "third");
DALI_TEST_CHECK(manager.GetFocusOrder(third) == 1);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// check that the focus order of the second actor is increased to 2.
DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
// make sure the change of focus order doesn't affect the actor's description
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL) == "second");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "second");
// check that the focus order of the first actor is increased to 3.
DALI_TEST_CHECK(manager.GetFocusOrder(first) == 3);
// make sure the change of focus order doesn't affect the actor's description
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
END_TEST;
}
-int UtcDaliFocusManagerGenerateNewFocusOrder(void)
+int UtcDaliAccessibilityFocusManagerGenerateNewFocusOrder(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerGenerateNewFocusOrder");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerGenerateNewFocusOrder");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
DALI_TEST_CHECK(1 == manager.GenerateNewFocusOrder());
// Set the focus order for the first actor
manager.SetFocusOrder(first, 1);
- manager.SetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL, "first");
+ manager.SetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "first");
DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
//Test for new focus order
// Set the focus order for the first actor
manager.SetFocusOrder(second, 2);
- manager.SetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL, "first");
+ manager.SetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "first");
DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
END_TEST;
}
-int UtcDaliFocusManagerGetActorByFocusOrder(void)
+int UtcDaliAccessibilityFocusManagerGetActorByFocusOrder(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerGetActorByFocusOrder");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerGetActorByFocusOrder");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
// Create the actors and set their focus orders
END_TEST;
}
-int UtcDaliFocusManagerSetAndGetCurrentFocusActor(void)
+int UtcDaliAccessibilityFocusManagerSetAndGetCurrentFocusActor(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerSetAndGetCurrentFocusActor");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerSetAndGetCurrentFocusActor");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
// Create the first actor and add it to the stage
END_TEST;
}
-int UtcDaliFocusManagerGetCurrentFocusGroup(void)
+int UtcDaliAccessibilityFocusManagerGetCurrentFocusGroup(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerGetCurrentFocusGroup");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerGetCurrentFocusGroup");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
// Create an actor with two child actors and add it to the stage
END_TEST;
}
-int UtcDaliFocusManagerGetCurrentFocusOrder(void)
+int UtcDaliAccessibilityFocusManagerGetCurrentFocusOrder(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerGetCurrentFocusOrder");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerGetCurrentFocusOrder");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
Actor first = Actor::New();
// Set the focus order and description for the first actor
manager.SetFocusOrder(first, 1);
- manager.SetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL, "first");
+ manager.SetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "first");
DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Set the focus order and description for the second actor
manager.SetFocusOrder(second, 2);
- manager.SetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL, "second");
+ manager.SetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "second");
DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL) == "second");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "second");
// Set the focus order and description for the second actor
manager.SetFocusOrder(third, 3);
- manager.SetAccessibilityAttribute(third, FocusManager::ACCESSIBILITY_LABEL, "third");
+ manager.SetAccessibilityAttribute(third, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "third");
DALI_TEST_CHECK(manager.GetFocusOrder(third) == 3);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// Check that no actor is being focused yet.
DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 0);
END_TEST;
}
-int UtcDaliFocusManagerMoveFocusForward(void)
+int UtcDaliAccessibilityFocusManagerMoveFocusForward(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerMoveFocusForward");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerMoveFocusForward");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
Actor first = Actor::New();
// Set the focus order and description for the first actor
manager.SetFocusOrder(first, 1);
- manager.SetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL, "first");
+ manager.SetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "first");
DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Set the focus order and description for the second actor
manager.SetFocusOrder(second, 2);
- manager.SetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL, "second");
+ manager.SetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "second");
DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL) == "second");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "second");
// Set the focus order and description for the second actor
manager.SetFocusOrder(third, 3);
- manager.SetAccessibilityAttribute(third, FocusManager::ACCESSIBILITY_LABEL, "third");
+ manager.SetAccessibilityAttribute(third, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "third");
DALI_TEST_CHECK(manager.GetFocusOrder(third) == 3);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// Check that no actor is being focused yet.
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
// Set the focus on the first actor
DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Test the non-wrapped move first
manager.SetWrapMode(false);
// Move the focus forward to the second actor
manager.MoveFocusForward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "second");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "second");
// Move the focus forward to the third actor
manager.MoveFocusForward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// Check that it will fail to move the focus forward again as the third actor is the last
// focusable actor in the focus chain
manager.MoveFocusForward();
// The focus should still be set on the third actor
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// Now test the wrapped move
manager.SetWrapMode(true);
// Move the focus forward recursively and this time the first actor should be focused
manager.MoveFocusForward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Make the second actor not focusable
Property::Index propertyActorFocusable = second.GetPropertyIndex("focusable");
// the third actor should be focused now.
manager.MoveFocusForward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// Make the first actor invisible
first.SetVisible(false);
// so the focus will still be on the third actor
manager.MoveFocusForward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// Make the third actor invisible so that no actor can be focused.
third.SetVisible(false);
// Check that the focus move is failed as all the three actors can not be focused
manager.MoveFocusForward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
END_TEST;
}
-int UtcDaliFocusManagerMoveFocusBackward(void)
+int UtcDaliAccessibilityFocusManagerMoveFocusBackward(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerMoveFocusBackward");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerMoveFocusBackward");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
Actor first = Actor::New();
// Set the focus order and description for the first actor
manager.SetFocusOrder(first, 1);
- manager.SetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL, "first");
+ manager.SetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "first");
DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Set the focus order and description for the second actor
manager.SetFocusOrder(second, 2);
- manager.SetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL, "second");
+ manager.SetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "second");
DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, FocusManager::ACCESSIBILITY_LABEL) == "second");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "second");
// Set the focus order and description for the second actor
manager.SetFocusOrder(third, 3);
- manager.SetAccessibilityAttribute(third, FocusManager::ACCESSIBILITY_LABEL, "third");
+ manager.SetAccessibilityAttribute(third, AccessibilityFocusManager::ACCESSIBILITY_LABEL, "third");
DALI_TEST_CHECK(manager.GetFocusOrder(third) == 3);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// Check that no actor is being focused yet.
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
// Set the focus on the third actor
DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// Test the non-wrapped move first
manager.SetWrapMode(false);
// Move the focus backward to the second actor
manager.MoveFocusBackward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "second");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "second");
// Move the focus backward to the first actor
manager.MoveFocusBackward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Check that it will fail to move the focus backward again as the first actor is the first
// focusable actor in the focus chain
manager.MoveFocusBackward();
// The focus should still be set on the first actor
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Now test the wrapped move
manager.SetWrapMode(true);
// Move the focus backward recursively and this time the third actor should be focused
manager.MoveFocusBackward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "third");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "third");
// Make the second actor not focusable
Property::Index propertyActorFocusable = second.GetPropertyIndex("focusable");
// the first actor should be focused now.
manager.MoveFocusBackward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Make the third actor invisible
third.SetVisible(false);
// so the focus will still be on the first actor
manager.MoveFocusBackward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
// Make the first actor invisible so that no actor can be focused.
first.SetVisible(false);
// Check that the focus move is failed as all the three actors can not be focused
manager.MoveFocusBackward();
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
- DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), FocusManager::ACCESSIBILITY_LABEL) == "first");
+ DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityFocusManager::ACCESSIBILITY_LABEL) == "first");
END_TEST;
}
-int UtcDaliFocusManagerClearFocus(void)
+int UtcDaliAccessibilityFocusManagerClearFocus(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerClearFocus");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerClearFocus");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
// Create the first actor and add it to the stage
END_TEST;
}
-int UtcDaliFocusManagerReset(void)
+int UtcDaliAccessibilityFocusManagerReset(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerReset");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerReset");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
// Create the first actor and add it to the stage
END_TEST;
}
-int UtcDaliFocusManagerFocusGroup(void)
+int UtcDaliAccessibilityFocusManagerFocusGroup(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerFocusGroup");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerFocusGroup");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
// Create an actor with two child actors and add it to the stage
END_TEST;
}
-int UtcDaliFocusManagerSetAndGetFocusIndicator(void)
+int UtcDaliAccessibilityFocusManagerSetAndGetFocusIndicator(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerSetAndGetFocusIndicator");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerSetAndGetFocusIndicator");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
Actor defaultFocusIndicatorActor = manager.GetFocusIndicatorActor();
END_TEST;
}
-int UtcDaliFocusManagerSignalFocusChanged(void)
+int UtcDaliAccessibilityFocusManagerSignalFocusChanged(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerSignalFocusChanged");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerSignalFocusChanged");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
bool signalVerified = false;
END_TEST;
}
-int UtcDaliFocusManagerSignalFocusOvershot(void)
+int UtcDaliAccessibilityFocusManagerSignalFocusOvershot(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerSignalFocusOvershot");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerSignalFocusOvershot");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
bool signalVerified = false;
// Check that the forward focus movement is overshot.
callback.mCurrentFocusedActor = second;
- callback.mFocusOvershotDirection = Toolkit::FocusManager::OVERSHOT_NEXT;
+ callback.mFocusOvershotDirection = Toolkit::AccessibilityFocusManager::OVERSHOT_NEXT;
DALI_TEST_CHECK(manager.MoveFocusForward() == false);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
DALI_TEST_CHECK(signalVerified);
// Check that the backward focus movement is overshot.
callback.mCurrentFocusedActor = first;
- callback.mFocusOvershotDirection = Toolkit::FocusManager::OVERSHOT_PREVIOUS;
+ callback.mFocusOvershotDirection = Toolkit::AccessibilityFocusManager::OVERSHOT_PREVIOUS;
DALI_TEST_CHECK(manager.MoveFocusBackward() == false);
DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
DALI_TEST_CHECK(signalVerified);
END_TEST;
}
-int UtcDaliFocusManagerSignalFocusedActorActivated(void)
+int UtcDaliAccessibilityFocusManagerSignalFocusedActorActivated(void)
{
ToolkitTestApplication application;
- tet_infoline(" UtcDaliFocusManagerSignalFocusedActorActivated");
+ tet_infoline(" UtcDaliAccessibilityFocusManagerSignalFocusedActorActivated");
- FocusManager manager = FocusManager::Get();
+ AccessibilityFocusManager manager = AccessibilityFocusManager::Get();
DALI_TEST_CHECK(manager);
FocusedActorActivatedCallback callback;
#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/keyinput-focus-manager.h>
#include "dummy-control.h"
develapisliderdir = $(develapicontrolsdir)/slider
develapishadowviewdir = $(develapicontrolsdir)/shadow-view
develapisuperblurviewdir = $(develapicontrolsdir)/super-blur-view
+develapifocusmanagerdir = $(develapidir)/focus-manager
develapiscriptingdir = $(develapidir)/scripting
develapibubbleeffectdir = $(develapidir)/shader-effects/bubble-effect
develapishadereffectsdir = $(develapidir)/shader-effects
develapibubbleeffect_HEADERS = $(devel_api_bubble_effect_header_files)
develapibuilder_HEADERS = $(devel_api_builder_header_files)
develapieffectsview_HEADERS = $(devel_api_effects_view_header_files)
+develapifocusmanager_HEADERS = $(devel_api_focus_manager_header_files)
develapimagnifier_HEADERS = $(devel_api_magnifier_header_files)
develapipageturnview_HEADERS = $(devel_api_page_turn_view_header_files)
develapipopup_HEADERS = $(devel_api_popup_header_files)
#include <dali-toolkit/public-api/controls/table-view/table-view.h>
#include <dali-toolkit/public-api/controls/text-controls/text-field.h>
#include <dali-toolkit/public-api/controls/text-controls/text-label.h>
-#include <dali-toolkit/public-api/focus-manager/focus-manager.h>
+#include <dali-toolkit/public-api/focus-manager/accessibility-focus-manager.h>
#include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
-#include <dali-toolkit/public-api/focus-manager/keyinput-focus-manager.h>
#include <dali-toolkit/public-api/text/rendering-backend.h>
#include <dali-toolkit/public-api/dali-toolkit-version.h>
#include <dali-toolkit/public-api/enums.h>
$(devel_api_src_dir)/controls/super-blur-view/super-blur-view.cpp \
$(devel_api_src_dir)/controls/text-controls/text-selection-popup.cpp \
$(devel_api_src_dir)/controls/tool-bar/tool-bar.cpp \
+ $(devel_api_src_dir)/focus-manager/keyinput-focus-manager.cpp \
$(devel_api_src_dir)/styling/style-manager.cpp \
$(devel_api_src_dir)/scripting/script.cpp \
$(devel_api_src_dir)/shader-effects/bubble-effect/bubble-effect.cpp \
devel_api_slider_header_files = \
$(devel_api_src_dir)/controls/slider/slider.h
+devel_api_focus_manager_header_files = \
+ $(devel_api_src_dir)/focus-manager/keyinput-focus-manager.h
+
devel_api_styling_header_files = \
$(devel_api_src_dir)/styling/style-manager.h
#include <dali-toolkit/public-api/controls/buttons/button.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali-toolkit/public-api/controls/default-controls/solid-color-actor.h>
-#include <dali-toolkit/public-api/focus-manager/focus-manager.h>
+#include <dali-toolkit/public-api/focus-manager/accessibility-focus-manager.h>
#include <dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.h>
#include <dali-toolkit/internal/controls/buttons/button-impl.h>
$(toolkit_src_dir)/controls/text-controls/text-label-impl.cpp \
$(toolkit_src_dir)/controls/text-controls/text-selection-popup-impl.cpp \
$(toolkit_src_dir)/controls/tool-bar/tool-bar-impl.cpp \
- $(toolkit_src_dir)/focus-manager/focus-manager-impl.cpp \
+ $(toolkit_src_dir)/focus-manager/accessibility-focus-manager-impl.cpp \
$(toolkit_src_dir)/focus-manager/keyboard-focus-manager-impl.cpp \
$(toolkit_src_dir)/focus-manager/keyinput-focus-manager-impl.cpp \
$(toolkit_src_dir)/filters/blur-two-pass-filter.cpp \
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
*/
// CLASS HEADER
-#include "focus-manager-impl.h"
+#include "accessibility-focus-manager-impl.h"
// EXTERNAL INCLUDES
#include <cstring> // for strcmp
}
-FocusManager::FocusManager()
+AccessibilityFocusManager::AccessibilityFocusManager()
: mIsWrapped(false),
mIsFocusWithinGroup(false),
mIsEndcapFeedbackEnabled(false),
ChangeAccessibilityStatus();
}
-FocusManager::~FocusManager()
+AccessibilityFocusManager::~AccessibilityFocusManager()
{
}
-FocusManager::ActorAdditionalInfo FocusManager::GetActorAdditionalInfo(const unsigned int actorID) const
+AccessibilityFocusManager::ActorAdditionalInfo AccessibilityFocusManager::GetActorAdditionalInfo(const unsigned int actorID) const
{
ActorAdditionalInfo data;
IDAdditionalInfoConstIter iter = mIDAdditionalInfoContainer.find(actorID);
return data;
}
-void FocusManager::SynchronizeActorAdditionalInfo(const unsigned int actorID, const unsigned int order)
+void AccessibilityFocusManager::SynchronizeActorAdditionalInfo(const unsigned int actorID, const unsigned int order)
{
ActorAdditionalInfo actorInfo = GetActorAdditionalInfo(actorID);
actorInfo.mFocusOrder = order;
mIDAdditionalInfoContainer.insert(IDAdditionalInfoPair(actorID, actorInfo));
}
-void FocusManager::SetAccessibilityAttribute(Actor actor, Toolkit::FocusManager::AccessibilityAttribute type, const std::string& text)
+void AccessibilityFocusManager::SetAccessibilityAttribute(Actor actor, Toolkit::AccessibilityFocusManager::AccessibilityAttribute type, const std::string& text)
{
if(actor)
{
}
}
-std::string FocusManager::GetAccessibilityAttribute(Actor actor, Toolkit::FocusManager::AccessibilityAttribute type) const
+std::string AccessibilityFocusManager::GetAccessibilityAttribute(Actor actor, Toolkit::AccessibilityFocusManager::AccessibilityAttribute type) const
{
std::string text;
return text;
}
-void FocusManager::SetFocusOrder(Actor actor, const unsigned int order)
+void AccessibilityFocusManager::SetFocusOrder(Actor actor, const unsigned int order)
{
// Do nothing if the focus order of the actor is not changed.
if(actor && GetFocusOrder(actor) != order)
}
}
-unsigned int FocusManager::GetFocusOrder(Actor actor) const
+unsigned int AccessibilityFocusManager::GetFocusOrder(Actor actor) const
{
unsigned int focusOrder = 0;
return focusOrder;
}
-unsigned int FocusManager::GenerateNewFocusOrder() const
+unsigned int AccessibilityFocusManager::GenerateNewFocusOrder() const
{
unsigned int order = 1;
FocusIDContainer::const_reverse_iterator iter = mFocusIDContainer.rbegin();
return order;
}
-Actor FocusManager::GetActorByFocusOrder(const unsigned int order)
+Actor AccessibilityFocusManager::GetActorByFocusOrder(const unsigned int order)
{
Actor actor = Actor();
return actor;
}
-bool FocusManager::SetCurrentFocusActor(Actor actor)
+bool AccessibilityFocusManager::SetCurrentFocusActor(Actor actor)
{
if(actor)
{
return false;
}
-bool FocusManager::DoSetCurrentFocusActor(const unsigned int actorID)
+bool AccessibilityFocusManager::DoSetCurrentFocusActor(const unsigned int actorID)
{
Actor rootActor = Stage::GetCurrent().GetRootLayer();
// Combine attribute texts to one text
std::string informationText;
- for(int i = 0; i < Toolkit::FocusManager::ACCESSIBILITY_ATTRIBUTE_NUM; i++)
+ for(int i = 0; i < Toolkit::AccessibilityFocusManager::ACCESSIBILITY_ATTRIBUTE_NUM; i++)
{
if(!GetActorAdditionalInfo(actorID).mAccessibilityAttributes[i].empty())
{
return false;
}
-Actor FocusManager::GetCurrentFocusActor()
+Actor AccessibilityFocusManager::GetCurrentFocusActor()
{
Actor rootActor = Stage::GetCurrent().GetRootLayer();
return rootActor.FindChildById(mCurrentFocusActor.second);
}
-Actor FocusManager::GetCurrentFocusGroup()
+Actor AccessibilityFocusManager::GetCurrentFocusGroup()
{
return GetFocusGroup(GetCurrentFocusActor());
}
-unsigned int FocusManager::GetCurrentFocusOrder()
+unsigned int AccessibilityFocusManager::GetCurrentFocusOrder()
{
return mCurrentFocusActor.first;
}
-bool FocusManager::MoveFocusForward()
+bool AccessibilityFocusManager::MoveFocusForward()
{
bool ret = false;
mRecursiveFocusMoveCounter = 0;
return ret;
}
-bool FocusManager::MoveFocusBackward()
+bool AccessibilityFocusManager::MoveFocusBackward()
{
bool ret = false;
mRecursiveFocusMoveCounter = 0;
return ret;
}
-void FocusManager::DoActivate(Actor actor)
+void AccessibilityFocusManager::DoActivate(Actor actor)
{
if(actor)
{
}
}
-void FocusManager::ClearFocus()
+void AccessibilityFocusManager::ClearFocus()
{
Actor actor = GetCurrentFocusActor();
if(actor)
}
}
-void FocusManager::Reset()
+void AccessibilityFocusManager::Reset()
{
ClearFocus();
mFocusIDContainer.clear();
mIDAdditionalInfoContainer.clear();
}
-void FocusManager::SetFocusGroup(Actor actor, bool isFocusGroup)
+void AccessibilityFocusManager::SetFocusGroup(Actor actor, bool isFocusGroup)
{
if(actor)
{
}
}
-bool FocusManager::IsFocusGroup(Actor actor) const
+bool AccessibilityFocusManager::IsFocusGroup(Actor actor) const
{
// Check whether the actor is a focus group
bool isFocusGroup = false;
return isFocusGroup;
}
-Actor FocusManager::GetFocusGroup(Actor actor)
+Actor AccessibilityFocusManager::GetFocusGroup(Actor actor)
{
// Go through the actor's hierarchy to check which focus group the actor belongs to
while (actor && !IsFocusGroup(actor))
return actor;
}
-void FocusManager::SetGroupMode(bool enabled)
+void AccessibilityFocusManager::SetGroupMode(bool enabled)
{
mIsFocusWithinGroup = enabled;
}
-bool FocusManager::GetGroupMode() const
+bool AccessibilityFocusManager::GetGroupMode() const
{
return mIsFocusWithinGroup;
}
-void FocusManager::SetWrapMode(bool wrapped)
+void AccessibilityFocusManager::SetWrapMode(bool wrapped)
{
mIsWrapped = wrapped;
}
-bool FocusManager::GetWrapMode() const
+bool AccessibilityFocusManager::GetWrapMode() const
{
return mIsWrapped;
}
-void FocusManager::SetFocusIndicatorActor(Actor indicator)
+void AccessibilityFocusManager::SetFocusIndicatorActor(Actor indicator)
{
mFocusIndicatorActor = indicator;
}
-Actor FocusManager::GetFocusIndicatorActor()
+Actor AccessibilityFocusManager::GetFocusIndicatorActor()
{
return mFocusIndicatorActor;
}
-bool FocusManager::DoMoveFocus(FocusIDIter focusIDIter, bool forward, bool wrapped)
+bool AccessibilityFocusManager::DoMoveFocus(FocusIDIter focusIDIter, bool forward, bool wrapped)
{
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] %d focusable actors\n", __FUNCTION__, __LINE__, mFocusIDContainer.size());
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] focus order : %d\n", __FUNCTION__, __LINE__, (*focusIDIter).first);
{
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] Overshot\n", __FUNCTION__, __LINE__);
// Send notification for handling overshooted situation
- mFocusOvershotSignal.Emit(GetCurrentFocusActor(), forward ? Toolkit::FocusManager::OVERSHOT_NEXT : Toolkit::FocusManager::OVERSHOT_PREVIOUS);
+ mFocusOvershotSignal.Emit(GetCurrentFocusActor(), forward ? Toolkit::AccessibilityFocusManager::OVERSHOT_NEXT : Toolkit::AccessibilityFocusManager::OVERSHOT_PREVIOUS);
return false; // Try to move the focus out of the scope
}
return true;
}
-void FocusManager::SetFocusable(Actor actor, bool focusable)
+void AccessibilityFocusManager::SetFocusable(Actor actor, bool focusable)
{
if(actor)
{
}
}
-void FocusManager::CreateDefaultFocusIndicatorActor()
+void AccessibilityFocusManager::CreateDefaultFocusIndicatorActor()
{
// Create a focus indicator actor shared by all the focusable actors
Image borderImage = ResourceImage::New(FOCUS_BORDER_IMAGE_PATH);
SetFocusIndicatorActor(focusIndicator);
}
-bool FocusManager::ChangeAccessibilityStatus()
+bool AccessibilityFocusManager::ChangeAccessibilityStatus()
{
AccessibilityManager manager = AccessibilityManager::Get();
mIsAccessibilityTtsEnabled = manager.IsEnabled();
return true;
}
-bool FocusManager::AccessibilityActionNext(bool allowEndFeedback)
+bool AccessibilityFocusManager::AccessibilityActionNext(bool allowEndFeedback)
{
if(mIsAccessibilityTtsEnabled)
{
}
}
-bool FocusManager::AccessibilityActionPrevious(bool allowEndFeedback)
+bool AccessibilityFocusManager::AccessibilityActionPrevious(bool allowEndFeedback)
{
if(mIsAccessibilityTtsEnabled)
{
}
}
-bool FocusManager::AccessibilityActionActivate()
+bool AccessibilityFocusManager::AccessibilityActionActivate()
{
bool ret = false;
return ret;
}
-bool FocusManager::AccessibilityActionRead(bool allowReadAgain)
+bool AccessibilityFocusManager::AccessibilityActionRead(bool allowReadAgain)
{
bool ret = false;
return ret;
}
-bool FocusManager::AccessibilityActionReadNext(bool allowEndFeedback)
+bool AccessibilityFocusManager::AccessibilityActionReadNext(bool allowEndFeedback)
{
if(mIsAccessibilityTtsEnabled)
{
}
}
-bool FocusManager::AccessibilityActionReadPrevious(bool allowEndFeedback)
+bool AccessibilityFocusManager::AccessibilityActionReadPrevious(bool allowEndFeedback)
{
if(mIsAccessibilityTtsEnabled)
{
}
}
-bool FocusManager::AccessibilityActionUp()
+bool AccessibilityFocusManager::AccessibilityActionUp()
{
bool ret = false;
return ret;
}
-bool FocusManager::AccessibilityActionDown()
+bool AccessibilityFocusManager::AccessibilityActionDown()
{
bool ret = false;
return ret;
}
-bool FocusManager::ClearAccessibilityFocus()
+bool AccessibilityFocusManager::ClearAccessibilityFocus()
{
if(mIsAccessibilityTtsEnabled)
{
}
}
-bool FocusManager::AccessibilityActionBack()
+bool AccessibilityFocusManager::AccessibilityActionBack()
{
// TODO: Back to previous view
return mIsAccessibilityTtsEnabled;
}
-bool FocusManager::AccessibilityActionTouch(const TouchEvent& touchEvent)
+bool AccessibilityFocusManager::AccessibilityActionTouch(const TouchEvent& touchEvent)
{
bool handled = false;
return handled;
}
-bool FocusManager::HandlePanGesture(const Integration::PanGestureEvent& panEvent)
+bool AccessibilityFocusManager::HandlePanGesture(const Integration::PanGestureEvent& panEvent)
{
bool handled = false;
return handled;
}
-Toolkit::FocusManager::FocusChangedSignalType& FocusManager::FocusChangedSignal()
+Toolkit::AccessibilityFocusManager::FocusChangedSignalType& AccessibilityFocusManager::FocusChangedSignal()
{
return mFocusChangedSignal;
}
-Toolkit::FocusManager::FocusOvershotSignalType& FocusManager::FocusOvershotSignal()
+Toolkit::AccessibilityFocusManager::FocusOvershotSignalType& AccessibilityFocusManager::FocusOvershotSignal()
{
return mFocusOvershotSignal;
}
-Toolkit::FocusManager::FocusedActorActivatedSignalType& FocusManager::FocusedActorActivatedSignal()
+Toolkit::AccessibilityFocusManager::FocusedActorActivatedSignalType& AccessibilityFocusManager::FocusedActorActivatedSignal()
{
return mFocusedActorActivatedSignal;
}
-bool FocusManager::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
+bool AccessibilityFocusManager::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
{
Dali::BaseHandle handle( object );
bool connected( true );
- FocusManager* manager = dynamic_cast<FocusManager*>( object );
+ AccessibilityFocusManager* manager = dynamic_cast<AccessibilityFocusManager*>( object );
if( 0 == strcmp( signalName.c_str(), SIGNAL_FOCUS_CHANGED ) )
{
-#ifndef __DALI_TOOLKIT_INTERNAL_FOCUS_MANAGER_H__
-#define __DALI_TOOLKIT_INTERNAL_FOCUS_MANAGER_H__
+#ifndef __DALI_TOOLKIT_INTERNAL_ACCESSIBILITY_FOCUS_MANAGER_H__
+#define __DALI_TOOLKIT_INTERNAL_ACCESSIBILITY_FOCUS_MANAGER_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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 <dali/integration-api/events/pan-gesture-event.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/focus-manager/focus-manager.h>
+#include <dali-toolkit/public-api/focus-manager/accessibility-focus-manager.h>
namespace Dali
{
namespace Internal
{
-class FocusManager;
+class AccessibilityFocusManager;
/**
- * @copydoc Toolkit::FocusManager
+ * @copydoc Toolkit::AccessibilityFocusManager
*/
-class FocusManager : public Dali::BaseObject, Dali::AccessibilityActionHandler, Dali::AccessibilityGestureHandler
+class AccessibilityFocusManager : public Dali::BaseObject, Dali::AccessibilityActionHandler, Dali::AccessibilityGestureHandler
{
public:
unsigned int mFocusOrder; ///< The focus order of the actor. It is undefined by default.
- std::string mAccessibilityAttributes[Toolkit::FocusManager::ACCESSIBILITY_ATTRIBUTE_NUM]; ///< The array of attribute texts
+ std::string mAccessibilityAttributes[Toolkit::AccessibilityFocusManager::ACCESSIBILITY_ATTRIBUTE_NUM]; ///< The array of attribute texts
};
typedef std::pair<unsigned int, unsigned int> FocusIDPair;
typedef IDAdditionalInfoContainer::const_iterator IDAdditionalInfoConstIter;
/**
- * Construct a new FocusManager.
+ * Construct a new AccessibilityFocusManager.
*/
- FocusManager();
+ AccessibilityFocusManager();
/**
- * @copydoc Toolkit::FocusManager::SetAccessibilityAttribute
+ * @copydoc Toolkit::AccessibilityFocusManager::SetAccessibilityAttribute
*/
- void SetAccessibilityAttribute(Actor actor, Toolkit::FocusManager::AccessibilityAttribute type, const std::string& text);
+ void SetAccessibilityAttribute(Actor actor, Toolkit::AccessibilityFocusManager::AccessibilityAttribute type, const std::string& text);
/**
- * @copydoc Toolkit::FocusManager::GetAccessibilityAttribute
+ * @copydoc Toolkit::AccessibilityFocusManager::GetAccessibilityAttribute
*/
- std::string GetAccessibilityAttribute(Actor actor, Toolkit::FocusManager::AccessibilityAttribute type) const;
+ std::string GetAccessibilityAttribute(Actor actor, Toolkit::AccessibilityFocusManager::AccessibilityAttribute type) const;
/**
- * @copydoc Toolkit::FocusManager::SetFocusOrder
+ * @copydoc Toolkit::AccessibilityFocusManager::SetFocusOrder
*/
void SetFocusOrder(Actor actor, const unsigned int order);
/**
- * @copydoc Toolkit::FocusManager::GetFocusOrder
+ * @copydoc Toolkit::AccessibilityFocusManager::GetFocusOrder
*/
unsigned int GetFocusOrder(Actor actor) const;
/**
- * @copydoc Toolkit::FocusManager::GenerateNewFocusOrder
+ * @copydoc Toolkit::AccessibilityFocusManager::GenerateNewFocusOrder
*/
unsigned int GenerateNewFocusOrder() const;
/**
- * @copydoc Toolkit::FocusManager::GetActorByFocusOrder
+ * @copydoc Toolkit::AccessibilityFocusManager::GetActorByFocusOrder
*/
Actor GetActorByFocusOrder(const unsigned int order);
/**
- * @copydoc Toolkit::FocusManager::SetCurrentFocusActor
+ * @copydoc Toolkit::AccessibilityFocusManager::SetCurrentFocusActor
*/
bool SetCurrentFocusActor(Actor actor);
/**
- * @copydoc Toolkit::FocusManager::GetCurrentFocusActor
+ * @copydoc Toolkit::AccessibilityFocusManager::GetCurrentFocusActor
*/
Actor GetCurrentFocusActor();
/**
- * @copydoc Toolkit::FocusManager::GetCurrentFocusGroup
+ * @copydoc Toolkit::AccessibilityFocusManager::GetCurrentFocusGroup
*/
Actor GetCurrentFocusGroup();
/**
- * @copydoc Toolkit::FocusManager::GetCurrentFocusOrder
+ * @copydoc Toolkit::AccessibilityFocusManager::GetCurrentFocusOrder
*/
unsigned int GetCurrentFocusOrder();
/**
- * @copydoc Toolkit::FocusManager::MoveFocusForward
+ * @copydoc Toolkit::AccessibilityFocusManager::MoveFocusForward
*/
bool MoveFocusForward();
/**
- * @copydoc Toolkit::FocusManager::MoveFocusBackward
+ * @copydoc Toolkit::AccessibilityFocusManager::MoveFocusBackward
*/
bool MoveFocusBackward();
/**
- * @copydoc Toolkit::FocusManager::ClearFocus
+ * @copydoc Toolkit::AccessibilityFocusManager::ClearFocus
*/
void ClearFocus();
/**
- * @copydoc Toolkit::FocusManager::Reset
+ * @copydoc Toolkit::AccessibilityFocusManager::Reset
*/
void Reset();
/**
- * @copydoc Toolkit::FocusManager::SetFocusGroup
+ * @copydoc Toolkit::AccessibilityFocusManager::SetFocusGroup
*/
void SetFocusGroup(Actor actor, bool isFocusGroup);
/**
- * @copydoc Toolkit::FocusManager::IsFocusGroup
+ * @copydoc Toolkit::AccessibilityFocusManager::IsFocusGroup
*/
bool IsFocusGroup(Actor actor) const;
/**
- * @copydoc Toolkit::FocusManager::SetGroupMode
+ * @copydoc Toolkit::AccessibilityFocusManager::SetGroupMode
*/
void SetGroupMode(bool enabled);
/**
- * @copydoc Toolkit::FocusManager::GetGroupMode
+ * @copydoc Toolkit::AccessibilityFocusManager::GetGroupMode
*/
bool GetGroupMode() const;
/**
- * @copydoc Toolkit::FocusManager::SetWrapMode
+ * @copydoc Toolkit::AccessibilityFocusManager::SetWrapMode
*/
void SetWrapMode(bool wrapped);
/**
- * @copydoc Toolkit::FocusManager::GetWrapMode
+ * @copydoc Toolkit::AccessibilityFocusManager::GetWrapMode
*/
bool GetWrapMode() const;
/**
- * @copydoc Toolkit::FocusManager::SetFocusIndicatorActor
+ * @copydoc Toolkit::AccessibilityFocusManager::SetFocusIndicatorActor
*/
void SetFocusIndicatorActor(Actor indicator);
/**
- * @copydoc Toolkit::FocusManager::GetFocusIndicatorActor
+ * @copydoc Toolkit::AccessibilityFocusManager::GetFocusIndicatorActor
*/
Actor GetFocusIndicatorActor();
/**
- * @copydoc Toolkit::FocusManager::GetFocusGroup
+ * @copydoc Toolkit::AccessibilityFocusManager::GetFocusGroup
*/
Actor GetFocusGroup(Actor actor);
public:
/**
- * @copydoc Toolkit::FocusManager::FocusChangedSignal()
+ * @copydoc Toolkit::AccessibilityFocusManager::FocusChangedSignal()
*/
- Toolkit::FocusManager::FocusChangedSignalType& FocusChangedSignal();
+ Toolkit::AccessibilityFocusManager::FocusChangedSignalType& FocusChangedSignal();
/**
- * @copydoc Toolkit::FocusManager::FocusOvershotSignal()
+ * @copydoc Toolkit::AccessibilityFocusManager::FocusOvershotSignal()
*/
- Toolkit::FocusManager::FocusOvershotSignalType& FocusOvershotSignal();
+ Toolkit::AccessibilityFocusManager::FocusOvershotSignalType& FocusOvershotSignal();
/**
- * @copydoc Toolkit::FocusManager::FocusedActorActivatedSignal()
+ * @copydoc Toolkit::AccessibilityFocusManager::FocusedActorActivatedSignal()
*/
- Toolkit::FocusManager::FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
+ Toolkit::AccessibilityFocusManager::FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
/**
* Connects a callback function with the object's signals.
/**
* Destructor
*/
- virtual ~FocusManager();
+ virtual ~AccessibilityFocusManager();
private:
private:
// Undefined
- FocusManager(const FocusManager&);
+ AccessibilityFocusManager(const AccessibilityFocusManager&);
- FocusManager& operator=(const FocusManager& rhs);
+ AccessibilityFocusManager& operator=(const AccessibilityFocusManager& rhs);
private:
- Toolkit::FocusManager::FocusChangedSignalType mFocusChangedSignal; ///< The signal to notify the focus change
- Toolkit::FocusManager::FocusOvershotSignalType mFocusOvershotSignal; ///< The signal to notify the focus overshooted
- Toolkit::FocusManager::FocusedActorActivatedSignalType mFocusedActorActivatedSignal; ///< The signal to notify the activation of focused actor
+ Toolkit::AccessibilityFocusManager::FocusChangedSignalType mFocusChangedSignal; ///< The signal to notify the focus change
+ Toolkit::AccessibilityFocusManager::FocusOvershotSignalType mFocusOvershotSignal; ///< The signal to notify the focus overshooted
+ Toolkit::AccessibilityFocusManager::FocusedActorActivatedSignalType mFocusedActorActivatedSignal; ///< The signal to notify the activation of focused actor
bool mIsWrapped; ///< Whether the focus movement is wrapped around or not
bool mIsFocusWithinGroup; ///< Whether the focus movement is limited to the current focus group or not
} // namespace Internal
-inline Internal::FocusManager& GetImpl(Dali::Toolkit::FocusManager& obj)
+inline Internal::AccessibilityFocusManager& GetImpl(Dali::Toolkit::AccessibilityFocusManager& obj)
{
DALI_ASSERT_ALWAYS(obj);
Dali::BaseObject& handle = obj.GetBaseObject();
- return static_cast<Internal::FocusManager&>(handle);
+ return static_cast<Internal::AccessibilityFocusManager&>(handle);
}
-inline const Internal::FocusManager& GetImpl(const Dali::Toolkit::FocusManager& obj)
+inline const Internal::AccessibilityFocusManager& GetImpl(const Dali::Toolkit::AccessibilityFocusManager& obj)
{
DALI_ASSERT_ALWAYS(obj);
const Dali::BaseObject& handle = obj.GetBaseObject();
- return static_cast<const Internal::FocusManager&>(handle);
+ return static_cast<const Internal::AccessibilityFocusManager&>(handle);
}
} // namespace Toolkit
} // namespace Dali
-#endif // __DALI_TOOLKIT_INTERNAL_FOCUS_MANAGER_H__
+#endif // __DALI_TOOLKIT_INTERNAL_ACCESSIBILITY_FOCUS_MANAGER_H__
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
-#include <dali-toolkit/public-api/focus-manager/focus-manager.h>
-#include <dali-toolkit/public-api/focus-manager/keyinput-focus-manager.h>
+#include <dali-toolkit/public-api/focus-manager/accessibility-focus-manager.h>
+#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
namespace Dali
{
// Save the current focused actor
mCurrentFocusActor = actorID;
- // Move the accessibility focus to the same actor
-// Toolkit::FocusManager focusManager = Toolkit::FocusManager::Get();
-// focusManager.SetCurrentFocusActor(actor);
-
DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] SUCCEED\n", __FUNCTION__, __LINE__);
return true;
}
AccessibilityManager accessibilityManager = AccessibilityManager::Get();
bool isAccessibilityEnabled = accessibilityManager.IsEnabled();
- Toolkit::FocusManager accessibilityFocusManager = Toolkit::FocusManager::Get();
+ Toolkit::AccessibilityFocusManager accessibilityFocusManager = Toolkit::AccessibilityFocusManager::Get();
std::string keyName = event.keyPressedName;
#include <dali/public-api/object/object-registry.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/focus-manager/keyinput-focus-manager.h>
+#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
#include <dali-toolkit/public-api/controls/control.h>
namespace Dali
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/focus-manager/keyinput-focus-manager.h>
+#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
#include <dali-toolkit/public-api/focus-manager/keyboard-focus-manager.h>
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/devel-api/styling/style-manager.h>
namespace Internal
{
-class FocusManager;
-class KeyboardFocusManager;
-class KeyInputFocusManager;
/**
* @brief This is the internal base class for all controls.
// Called by Focus Manager
/**
- * @brief Called by the focus manager and keyboard focus manager to Activate the Control
+ * @brief Called by the accessibility focus manager and keyboard focus manager to activate the Control
*/
DALI_INTERNAL void AccessibilityActivate();
$(public_api_src_dir)/controls/text-controls/text-label.cpp \
$(public_api_src_dir)/controls/text-controls/text-field.cpp \
$(public_api_src_dir)/controls/gaussian-blur-view/gaussian-blur-view.cpp \
- $(public_api_src_dir)/focus-manager/focus-manager.cpp \
+ $(public_api_src_dir)/focus-manager/accessibility-focus-manager.cpp \
$(public_api_src_dir)/focus-manager/keyboard-focus-manager.cpp \
- $(public_api_src_dir)/focus-manager/keyinput-focus-manager.cpp \
$(public_api_src_dir)/dali-toolkit-version.cpp \
$(public_api_src_dir)/enums.cpp
public_api_text_controls_header_files = \
$(public_api_src_dir)/controls/text-controls/text-label.h \
- $(public_api_src_dir)/controls/text-controls/text-field.h
+ $(public_api_src_dir)/controls/text-controls/text-field.h
public_api_focus_manager_header_files = \
- $(public_api_src_dir)/focus-manager/focus-manager.h \
- $(public_api_src_dir)/focus-manager/keyboard-focus-manager.h \
- $(public_api_src_dir)/focus-manager/keyinput-focus-manager.h
+ $(public_api_src_dir)/focus-manager/accessibility-focus-manager.h \
+ $(public_api_src_dir)/focus-manager/keyboard-focus-manager.h
public_api_rendering_backend_header_files = \
$(public_api_src_dir)/text/rendering-backend.h
--- /dev/null
+/*
+ * Copyright (c) 2015 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali-toolkit/public-api/focus-manager/accessibility-focus-manager.h>
+
+// EXTERNAL INCLUDES
+#include <dali/devel-api/adaptor-framework/singleton-service.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/focus-manager/accessibility-focus-manager-impl.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+AccessibilityFocusManager::AccessibilityFocusManager()
+{
+}
+
+AccessibilityFocusManager::~AccessibilityFocusManager()
+{
+}
+
+AccessibilityFocusManager AccessibilityFocusManager::Get()
+{
+ AccessibilityFocusManager manager;
+
+ // Check whether the accessibility focus manager is already created
+ SingletonService singletonService( SingletonService::Get() );
+ if ( singletonService )
+ {
+ Dali::BaseHandle handle = singletonService.GetSingleton(typeid(AccessibilityFocusManager));
+ if(handle)
+ {
+ // If so, downcast the handle of singleton to focus manager
+ manager = AccessibilityFocusManager(dynamic_cast<Internal::AccessibilityFocusManager*>(handle.GetObjectPtr()));
+ }
+
+ if(!manager)
+ {
+ // If not, create the accessibility focus manager and register it as a singleton
+ manager = AccessibilityFocusManager(new Internal::AccessibilityFocusManager());
+ singletonService.Register(typeid(manager), manager);
+ }
+ }
+
+ return manager;
+}
+
+AccessibilityFocusManager::AccessibilityFocusManager(Internal::AccessibilityFocusManager *impl)
+ : BaseHandle(impl)
+{
+}
+
+void AccessibilityFocusManager::SetAccessibilityAttribute(Actor actor, AccessibilityAttribute type, const std::string& text)
+{
+ GetImpl(*this).SetAccessibilityAttribute(actor, type, text);
+}
+
+std::string AccessibilityFocusManager::GetAccessibilityAttribute(Actor actor, AccessibilityAttribute type) const
+{
+ return GetImpl(*this).GetAccessibilityAttribute(actor, type);
+}
+
+void AccessibilityFocusManager::SetFocusOrder(Actor actor, const unsigned int order)
+{
+ GetImpl(*this).SetFocusOrder(actor, order);
+}
+
+unsigned int AccessibilityFocusManager::GetFocusOrder(Actor actor) const
+{
+ return GetImpl(*this).GetFocusOrder(actor);
+}
+
+unsigned int AccessibilityFocusManager::GenerateNewFocusOrder() const
+{
+ return GetImpl(*this).GenerateNewFocusOrder();
+}
+
+Actor AccessibilityFocusManager::GetActorByFocusOrder(const unsigned int order)
+{
+ return GetImpl(*this).GetActorByFocusOrder(order);
+}
+
+bool AccessibilityFocusManager::SetCurrentFocusActor(Actor actor)
+{
+ return GetImpl(*this).SetCurrentFocusActor(actor);
+}
+
+Actor AccessibilityFocusManager::GetCurrentFocusActor()
+{
+ return GetImpl(*this).GetCurrentFocusActor();
+}
+
+Actor AccessibilityFocusManager::GetCurrentFocusGroup()
+{
+ return GetImpl(*this).GetCurrentFocusGroup();
+}
+
+unsigned int AccessibilityFocusManager::GetCurrentFocusOrder()
+{
+ return GetImpl(*this).GetCurrentFocusOrder();
+}
+
+bool AccessibilityFocusManager::MoveFocusForward()
+{
+ return GetImpl(*this).MoveFocusForward();
+}
+
+bool AccessibilityFocusManager::MoveFocusBackward()
+{
+ return GetImpl(*this).MoveFocusBackward();
+}
+
+void AccessibilityFocusManager::ClearFocus()
+{
+ GetImpl(*this).ClearFocus();
+}
+
+void AccessibilityFocusManager::Reset()
+{
+ GetImpl(*this).Reset();
+}
+
+void AccessibilityFocusManager::SetFocusGroup(Actor actor, bool isFocusGroup)
+{
+ GetImpl(*this).SetFocusGroup(actor, isFocusGroup);
+}
+
+bool AccessibilityFocusManager::IsFocusGroup(Actor actor) const
+{
+ return GetImpl(*this).IsFocusGroup(actor);
+}
+
+void AccessibilityFocusManager::SetGroupMode(bool enabled)
+{
+ GetImpl(*this).SetGroupMode(enabled);
+}
+
+bool AccessibilityFocusManager::GetGroupMode() const
+{
+ return GetImpl(*this).GetGroupMode();
+}
+
+void AccessibilityFocusManager::SetWrapMode(bool wrapped)
+{
+ GetImpl(*this).SetWrapMode(wrapped);
+}
+
+bool AccessibilityFocusManager::GetWrapMode() const
+{
+ return GetImpl(*this).GetWrapMode();
+}
+
+void AccessibilityFocusManager::SetFocusIndicatorActor(Actor indicator)
+{
+ GetImpl(*this).SetFocusIndicatorActor(indicator);
+}
+
+Actor AccessibilityFocusManager::GetFocusIndicatorActor()
+{
+ return GetImpl(*this).GetFocusIndicatorActor();
+}
+
+Actor AccessibilityFocusManager::GetFocusGroup(Actor actor)
+{
+ return GetImpl(*this).GetFocusGroup(actor);
+}
+
+AccessibilityFocusManager::FocusChangedSignalType& AccessibilityFocusManager::FocusChangedSignal()
+{
+ return GetImpl(*this).FocusChangedSignal();
+}
+
+AccessibilityFocusManager::FocusOvershotSignalType& AccessibilityFocusManager::FocusOvershotSignal()
+{
+ return GetImpl(*this).FocusOvershotSignal();
+}
+
+AccessibilityFocusManager::FocusedActorActivatedSignalType& AccessibilityFocusManager::FocusedActorActivatedSignal()
+{
+ return GetImpl(*this).FocusedActorActivatedSignal();
+}
+
+} // namespace Toolkit
+
+} // namespace Dali
-#ifndef __DALI_TOOLKIT_FOCUS_MANAGER_H__
-#define __DALI_TOOLKIT_FOCUS_MANAGER_H__
+#ifndef __DALI_TOOLKIT_ACCESSIBILITY_FOCUS_MANAGER_H__
+#define __DALI_TOOLKIT_ACCESSIBILITY_FOCUS_MANAGER_H__
/*
* Copyright (c) 2015 Samsung Electronics Co., Ltd.
namespace Internal DALI_INTERNAL
{
-class FocusManager;
+class AccessibilityFocusManager;
}
/**
- * @brief Manages registration of actors in a focus chain and changing the focused
- * actor within that chain.
+ * @brief Manages registration of actors in a accessibility focus chain and changing the
+ * focused actor within that chain.
*
* This class provides the functionality of registering the focus order and description
* of actors and maintaining the focus chain.
* | focus-overshot | @ref FocusOvershotSignal() |
* | focused-actor-activated | @ref FocusedActorActivatedSignal() |
*/
-class DALI_IMPORT_API FocusManager : public BaseHandle
+class DALI_IMPORT_API AccessibilityFocusManager : public BaseHandle
{
public:
typedef Signal< void ( Actor ) > FocusedActorActivatedSignalType;
/**
- * @brief Create a FocusManager handle; this can be initialised with FocusManager::New().
+ * @brief Create a AccessibilityFocusManager handle; this can be initialised with AccessibilityFocusManager::New().
*
* Calling member functions with an uninitialised handle is not allowed.
*/
- FocusManager();
+ AccessibilityFocusManager();
/**
* @brief Destructor
*
* This is non-virtual since derived Handle types must not contain data or virtual methods.
*/
- ~FocusManager();
+ ~AccessibilityFocusManager();
/**
- * @brief Get the singleton of FocusManager object.
+ * @brief Get the singleton of AccessibilityFocusManager object.
*
- * @return A handle to the FocusManager control.
+ * @return A handle to the AccessibilityFocusManager control.
*/
- static FocusManager Get();
+ static AccessibilityFocusManager Get();
/**
* @brief Set the information of the specified actor's accessibility attribute.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @pre The Actor has been initialized.
* @param actor The actor the text to be set with
* @param type The attribute type the text to be set with
/**
* @brief Get the text of the specified actor's accessibility attribute.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @pre The Actor has been initialized.
* @param actor The actor to be queried
* @param type The attribute type to be queried
* description but with no focus order being set yet) and therefore
* that actor is not focusable.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @pre The Actor has been initialized.
* @param actor The actor the focus order to be set with
* @param order The focus order of the actor
* When the focus order is 0, it means the focus order of the actor
* is undefined.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @pre The Actor has been initialized.
* @param actor The actor to be queried
* @return The focus order of the actor
* 1 where FOLast is the focus order of the very last control in the
* focus chain.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @return The focus order of the actor
*/
unsigned int GenerateNewFocusOrder() const;
* It will return an empty handle if the actor is not in the stage
* or has a focus order of 0.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @param order The focus order of the actor
*
* @return The actor that has the specified focus order or an empty
* have a defined focus order and must be focusable, visible and in
* the stage.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @pre The Actor has been initialized.
* @param actor The actor to be focused
* @return Whether the focus is successful or not
/**
* @brief Get the current focused actor.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @return A handle to the current focused actor or an empty handle if no actor is focused.
*/
Actor GetCurrentFocusActor();
/**
* @brief Get the focus group of current focused actor.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
*
* @return A handle to the immediate parent of the current focused
* actor which is also a focus group, or an empty handle if no actor
/**
* @brief Get the focus order of currently focused actor.
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
*
* @return The focus order of the currently focused actor or 0 if no
* actor is in focus.
* When the focus movement is wrapped around, the focus will be moved
* to the first focusable actor when it reaches the end of the focus chain.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @return true if the moving was successful
*/
bool MoveFocusForward();
* moved to the last focusable actor when it reaches the beginning
* of the focus chain.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @return true if the moving was successful
*/
bool MoveFocusBackward();
* that no actor is focused in the focus chain.
*
* It will emit focus changed signal without current focused actor
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
*/
void ClearFocus();
/**
* @brief Clear the every registered focusable actor from focus-manager.
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
*/
void Reset();
* @brief Set whether an actor is a focus group that can limit the
* scope of focus movement to its child actors in the focus chain.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @pre The Actor has been initialized.
* @param actor The actor to be set as a focus group.
* @param isFocusGroup Whether to set the actor to be a focus group or not.
/**
* @brief Check whether the actor is set as a focus group or not.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @pre The Actor has been initialized.
* @param actor The actor to be checked.
* @return Whether the actor is set as a focus group.
* When the group mode is enabled, the focus movement will be limited to the child actors
* of the current focus group including the current focus group itself. The current focus
* group is the closest ancestor of the current focused actor that set as a focus group.
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @param enabled Whether the group mode is enabled or not
*/
void SetGroupMode(bool enabled);
/**
* @brief Get whether the group mode is enabled or not.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @return Whether the group mode is enabled or not.
*/
bool GetGroupMode() const;
*
* When both the wrap mode and the group mode are enabled, focus will be
* wrapped within the current focus group. Focus will not be wrapped in default.
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @param wrapped Whether the focus movement is wrapped around or not
*/
void SetWrapMode(bool wrapped);
/**
* @brief Get whether the wrap mode is enabled or not.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @return Whether the wrap mode is enabled or not.
*/
bool GetWrapMode() const;
* @brief Set the focus indicator actor.
*
* This will replace the default focus indicator actor in
- * FocusManager and will be added to the focused actor as a
+ * AccessibilityFocusManager and will be added to the focused actor as a
* highlight.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @pre The indicator actor has been initialized.
* @param indicator The indicator actor to be added
*/
/**
* @brief Get the focus indicator actor.
*
- * @pre The FocusManager has been initialized.
+ * @pre The AccessibilityFocusManager has been initialized.
* @return A handle to the focus indicator actor
*/
Actor GetFocusIndicatorActor();
private:
- explicit DALI_INTERNAL FocusManager(Internal::FocusManager *impl);
+ explicit DALI_INTERNAL AccessibilityFocusManager(Internal::AccessibilityFocusManager *impl);
-}; // class FocusManager
+}; // class AccessibilityFocusManager
} // namespace Toolkit
+++ /dev/null
-/*
- * Copyright (c) 2015 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// CLASS HEADER
-#include <dali-toolkit/public-api/focus-manager/focus-manager.h>
-
-// EXTERNAL INCLUDES
-#include <dali/devel-api/adaptor-framework/singleton-service.h>
-
-// INTERNAL INCLUDES
-#include <dali-toolkit/internal/focus-manager/focus-manager-impl.h>
-
-namespace Dali
-{
-
-namespace Toolkit
-{
-
-FocusManager::FocusManager()
-{
-}
-
-FocusManager::~FocusManager()
-{
-}
-
-FocusManager FocusManager::Get()
-{
- FocusManager manager;
-
- // Check whether the focus manager is already created
- SingletonService singletonService( SingletonService::Get() );
- if ( singletonService )
- {
- Dali::BaseHandle handle = singletonService.GetSingleton(typeid(FocusManager));
- if(handle)
- {
- // If so, downcast the handle of singleton to focus manager
- manager = FocusManager(dynamic_cast<Internal::FocusManager*>(handle.GetObjectPtr()));
- }
-
- if(!manager)
- {
- // If not, create the focus manager and register it as a singleton
- manager = FocusManager(new Internal::FocusManager());
- singletonService.Register(typeid(manager), manager);
- }
- }
-
- return manager;
-}
-
-FocusManager::FocusManager(Internal::FocusManager *impl)
- : BaseHandle(impl)
-{
-}
-
-void FocusManager::SetAccessibilityAttribute(Actor actor, AccessibilityAttribute type, const std::string& text)
-{
- GetImpl(*this).SetAccessibilityAttribute(actor, type, text);
-}
-
-std::string FocusManager::GetAccessibilityAttribute(Actor actor, AccessibilityAttribute type) const
-{
- return GetImpl(*this).GetAccessibilityAttribute(actor, type);
-}
-
-void FocusManager::SetFocusOrder(Actor actor, const unsigned int order)
-{
- GetImpl(*this).SetFocusOrder(actor, order);
-}
-
-unsigned int FocusManager::GetFocusOrder(Actor actor) const
-{
- return GetImpl(*this).GetFocusOrder(actor);
-}
-
-unsigned int FocusManager::GenerateNewFocusOrder() const
-{
- return GetImpl(*this).GenerateNewFocusOrder();
-}
-
-Actor FocusManager::GetActorByFocusOrder(const unsigned int order)
-{
- return GetImpl(*this).GetActorByFocusOrder(order);
-}
-
-bool FocusManager::SetCurrentFocusActor(Actor actor)
-{
- return GetImpl(*this).SetCurrentFocusActor(actor);
-}
-
-Actor FocusManager::GetCurrentFocusActor()
-{
- return GetImpl(*this).GetCurrentFocusActor();
-}
-
-Actor FocusManager::GetCurrentFocusGroup()
-{
- return GetImpl(*this).GetCurrentFocusGroup();
-}
-
-unsigned int FocusManager::GetCurrentFocusOrder()
-{
- return GetImpl(*this).GetCurrentFocusOrder();
-}
-
-bool FocusManager::MoveFocusForward()
-{
- return GetImpl(*this).MoveFocusForward();
-}
-
-bool FocusManager::MoveFocusBackward()
-{
- return GetImpl(*this).MoveFocusBackward();
-}
-
-void FocusManager::ClearFocus()
-{
- GetImpl(*this).ClearFocus();
-}
-
-void FocusManager::Reset()
-{
- GetImpl(*this).Reset();
-}
-
-void FocusManager::SetFocusGroup(Actor actor, bool isFocusGroup)
-{
- GetImpl(*this).SetFocusGroup(actor, isFocusGroup);
-}
-
-bool FocusManager::IsFocusGroup(Actor actor) const
-{
- return GetImpl(*this).IsFocusGroup(actor);
-}
-
-void FocusManager::SetGroupMode(bool enabled)
-{
- GetImpl(*this).SetGroupMode(enabled);
-}
-
-bool FocusManager::GetGroupMode() const
-{
- return GetImpl(*this).GetGroupMode();
-}
-
-void FocusManager::SetWrapMode(bool wrapped)
-{
- GetImpl(*this).SetWrapMode(wrapped);
-}
-
-bool FocusManager::GetWrapMode() const
-{
- return GetImpl(*this).GetWrapMode();
-}
-
-void FocusManager::SetFocusIndicatorActor(Actor indicator)
-{
- GetImpl(*this).SetFocusIndicatorActor(indicator);
-}
-
-Actor FocusManager::GetFocusIndicatorActor()
-{
- return GetImpl(*this).GetFocusIndicatorActor();
-}
-
-Actor FocusManager::GetFocusGroup(Actor actor)
-{
- return GetImpl(*this).GetFocusGroup(actor);
-}
-
-FocusManager::FocusChangedSignalType& FocusManager::FocusChangedSignal()
-{
- return GetImpl(*this).FocusChangedSignal();
-}
-
-FocusManager::FocusOvershotSignalType& FocusManager::FocusOvershotSignal()
-{
- return GetImpl(*this).FocusOvershotSignal();
-}
-
-FocusManager::FocusedActorActivatedSignalType& FocusManager::FocusedActorActivatedSignal()
-{
- return GetImpl(*this).FocusedActorActivatedSignal();
-}
-
-} // namespace Toolkit
-
-} // namespace Dali