Change FocusFinder to a method

Change-Id: I7513ef3142fe649ad3d2c614b76b863b6d6c0c1a

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-KeyboardFocusManager.cpp b/automated-tests/src/dali-toolkit/utc-Dali-KeyboardFocusManager.cpp
index 55de778..053b25c 100644 (file)
--- a/automated-tests/src/dali-toolkit/utc-Dali-KeyboardFocusManager.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-KeyboardFocusManager.cpp
@@ -1643,22 +1643,22 @@ int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
   PushButton button4 = PushButton::New();
   PushButton button5 = 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);
+  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);
 
   application.GetScene().Add(button1);
   application.GetScene().Add(button2);
   application.GetScene().Add(button3);

-  application.GetScene().Add(button4);
+  button5.Add(button4);

   application.GetScene().Add(button5);
 
   // set position
   application.GetScene().Add(button5);
 
   // set position


@@ -1666,11 +1666,11 @@ int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
   //   |           |
   //   |    button5|
   // button3 -- button4
   //   |           |
   //   |    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(100.0f, 100.0f));
-  button5.SetProperty( Actor::Property::POSITION, Vector2(60.0f, 60.0f));
+  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();
 
   // flush the queue and render once
   application.SendNotification();


@@ -1698,7 +1698,7 @@ int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
 
   // Confirm whether focus is moved to 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_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(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);


@@ -1712,7 +1712,7 @@ int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::DOWN) == true);
 
   // Confirm whether focus is moved to button5
   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_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);
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button5);


@@ -1726,7 +1726,7 @@ int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
 
   // Confirm whether focus is moved to 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_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);
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button5);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button4);


@@ -1740,7 +1740,7 @@ int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
 
   // Confirm whether focus is moved to button5
   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_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);
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button4);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button5);


@@ -1754,7 +1754,35 @@ int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
 
   // Confirm whether focus is moved to button3
   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_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);
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button5);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button3);


@@ -1768,7 +1796,7 @@ int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == true);
 
   // Confirm whether focus is moved to button1
   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_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);
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button3);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);

diff --git a/dali-toolkit/devel-api/focus-manager/focus-finder.cpp b/dali-toolkit/devel-api/focus-manager/focus-finder.cpp
index d12ed11..952c261 100644 (file)
--- a/dali-toolkit/devel-api/focus-manager/focus-finder.cpp
+++ b/dali-toolkit/devel-api/focus-manager/focus-finder.cpp
@@ -15,63 +15,422 @@
  *\r
  */\r
 \r
  *\r
  */\r
 \r

+/*\r
+ * Copyright (C) 2017 The Android Open Source Project\r
+ *\r
+ * Modified by joogab yun(joogab.yun@samsung.com)\r
+ */\r
+\r

 // CLASS HEADER\r
 #include "focus-finder.h"\r
 \r
 // EXTERNAL INCLUDES\r
 // CLASS HEADER\r
 #include "focus-finder.h"\r
 \r
 // EXTERNAL INCLUDES\r

-#include <dali/devel-api/common/singleton-service.h>\r
-\r
-// INTERNAL INCLUDES\r
-#include <dali-toolkit/internal/focus-manager/focus-finder-impl.h>\r
+#include <dali/devel-api/actors/actor-devel.h>\r
+#include <dali/integration-api/adaptor-framework/scene-holder.h>\r
+#include <dali/public-api/actors/layer.h>\r

 \r
 namespace Dali\r
 {\r
 namespace Toolkit\r
 {\r
 \r
 namespace Dali\r
 {\r
 namespace Toolkit\r
 {\r

-FocusFinder::FocusFinder()\r
+namespace FocusFinder\r
+{\r
+namespace\r
+{\r
+static int MajorAxisDistanceRaw(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
+{\r
+  switch(direction)\r
+  {\r
+    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
+    {\r
+      return source.left - dest.right;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
+    {\r
+      return dest.left - source.right;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
+    {\r
+      return source.top - dest.bottom;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
+    {\r
+      return dest.top - source.bottom;\r
+    }\r
+    default:\r
+    {\r
+      return 0;\r
+    }\r
+  }\r
+}\r
+\r
+/**\r
+ * @return The distance from the edge furthest in the given direction\r
+ *   of source to the edge nearest in the given direction of dest.\r
+ *   If the dest is not in the direction from source, return 0.\r
+ */\r
+static int MajorAxisDistance(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r

 {\r
 {\r

+  return std::max(0, MajorAxisDistanceRaw(direction, source, dest));\r

 }\r
 \r
 }\r
 \r

-FocusFinder::~FocusFinder()\r
+static int MajorAxisDistanceToFarEdgeRaw(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r

 {\r
 {\r

+  switch(direction)\r
+  {\r
+    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
+    {\r
+      return source.left - dest.left;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
+    {\r
+      return dest.right - source.right;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
+    {\r
+      return source.top - dest.top;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
+    {\r
+      return dest.bottom - source.bottom;\r
+    }\r
+    default:\r
+    {\r
+      return 0;\r
+    }\r
+  }\r

 }\r
 \r
 }\r
 \r

-FocusFinder FocusFinder::Get()\r
+/**\r
+ * @return The distance along the major axis w.r.t the direction from the\r
+ *   edge of source to the far edge of dest.\r
+ *   If the dest is not in the direction from source, return 1\r
+ */\r
+static int MajorAxisDistanceToFarEdge(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r

 {\r
 {\r

-  FocusFinder finder;\r
+  return std::max(1, MajorAxisDistanceToFarEdgeRaw(direction, source, dest));\r
+}\r

 \r
 \r

-  // Check whether the focus finder is already created\r
-  SingletonService singletonService(SingletonService::Get());\r
-  if(singletonService)\r
+/**\r
+ * Find the distance on the minor axis w.r.t the direction to the nearest\r
+ * edge of the destination rectangle.\r
+ * @param direction the direction (up, down, left, right)\r
+ * @param source The source rect.\r
+ * @param dest The destination rect.\r
+ * @return The distance.\r
+ */\r
+static int MinorAxisDistance(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
+{\r
+  switch(direction)\r

   {\r
   {\r

-    Dali::BaseHandle handle = singletonService.GetSingleton(typeid(FocusFinder));\r
-    if(handle)\r
+    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
+    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
+    {\r
+      // the distance between the center verticals\r
+      return std::abs(\r
+        (((source.top + source.bottom) * 0.5f) -\r
+         (((dest.top + dest.bottom) * 0.5f))));\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
+    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r

     {\r
     {\r

-      // If so, downcast the handle of singleton to focus finder\r
-      finder = FocusFinder(dynamic_cast<Internal::FocusFinder*>(handle.GetObjectPtr()));\r
+      // the distance between the center horizontals\r
+      return std::abs(\r
+        (((source.left + source.right) * 0.5f) -\r
+         (((dest.left + dest.right) * 0.5f))));\r

     }\r
     }\r

+    default:\r
+    {\r
+      return 0;\r
+    }\r
+  }\r
+}\r
+\r
+/**\r
+ * Calculate distance given major and minor axis distances.\r
+ * @param majorAxisDistance The majorAxisDistance\r
+ * @param minorAxisDistance The minorAxisDistance\r
+ * @return The distance\r
+ */\r
+static int GetWeightedDistanceFor(int majorAxisDistance, int minorAxisDistance)\r
+{\r
+  return 13 * majorAxisDistance * majorAxisDistance + minorAxisDistance * minorAxisDistance;\r
+}\r
+\r
+/**\r
+ * Convert x,y,width,height coordinates into left, right, bottom, top coordinates.\r
+ * @param[in,out] rect The rect\r
+ */\r
+static void ConvertCoordinate(Dali::Rect<float>& rect)\r
+{\r
+  // convert x, y, width, height -> left, right, bottom, top\r
+  float left   = rect.x;\r
+  float right  = rect.x + rect.width;\r
+  float bottom = rect.y + rect.height;\r
+  float top    = rect.y;\r
+\r
+  rect.left   = left;\r
+  rect.right  = right;\r
+  rect.bottom = bottom;\r
+  rect.top    = top;\r
+}\r

 \r
 \r

-    if(!finder)\r
+/**\r
+ * Is destRect a candidate for the next focus given the direction?\r
+ * @param srcRect The source rect.\r
+ * @param destRect The dest rect.\r
+ * @param direction The direction (up, down, left, right)\r
+ * @return Whether destRect is a candidate.\r
+ */\r
+static bool IsCandidate(Dali::Rect<float> srcRect, Dali::Rect<float> destRect, Dali::Toolkit::Control::KeyboardFocus::Direction direction)\r
+{\r
+  switch(direction)\r
+  {\r
+    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
+    {\r
+      return (srcRect.right > destRect.right || srcRect.left >= destRect.right) && srcRect.left > destRect.left;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
+    {\r
+      return (srcRect.left < destRect.left || srcRect.right <= destRect.left) && srcRect.right < destRect.right;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
+    {\r
+      return (srcRect.bottom > destRect.bottom || srcRect.top >= destRect.bottom) && srcRect.top > destRect.top;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r

     {\r
     {\r

-      // If not, create the focus finder and register it as a singleton\r
-      finder = FocusFinder(new Internal::FocusFinder());\r
-      singletonService.Register(typeid(finder), finder);\r
+      return (srcRect.top < destRect.top || srcRect.bottom <= destRect.top) && srcRect.bottom < destRect.bottom;\r
+    }\r
+    default:\r
+    {\r
+      return false;\r

     }\r
   }\r
     }\r
   }\r

+  return false;\r
+}\r

 \r
 \r

-  return finder;\r
+/**\r
+ * Is dest in a given direction from src?\r
+ * @param direction the direction (up, down, left, right)\r
+ * @param src The source rect\r
+ * @param dest The dest rect\r
+ */\r
+static bool IsToDirectionOf(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> src, Dali::Rect<float> dest)\r
+{\r
+  switch(direction)\r
+  {\r
+    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
+    {\r
+      return src.left >= dest.right;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
+    {\r
+      return src.right <= dest.left;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
+    {\r
+      return src.top >= dest.bottom;\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
+    {\r
+      return src.bottom <= dest.top;\r
+    }\r
+    default:\r
+    {\r
+      return false;\r
+    }\r
+  }\r
+}\r
+\r
+/**\r
+ * Do the given direction's axis of rect1 and rect2 overlap?\r
+ * @param direction the direction (up, down, left, right)\r
+ * @param rect1 The first rect\r
+ * @param rect2 The second rect\r
+ * @return whether the beams overlap\r
+ */\r
+static bool BeamsOverlap(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> rect1, Dali::Rect<float> rect2)\r
+{\r
+  switch(direction)\r
+  {\r
+    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
+    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
+    {\r
+      return (rect2.bottom >= rect1.top) && (rect2.top <= rect1.bottom);\r
+    }\r
+    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
+    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
+    {\r
+      return (rect2.right >= rect1.left) && (rect2.left <= rect1.right);\r
+    }\r
+    default:\r
+    {\r
+      return false;\r
+    }\r
+  }\r

 }\r
 \r
 }\r
 \r

-FocusFinder::FocusFinder(Internal::FocusFinder* impl)\r
-: BaseHandle(impl)\r
+/**\r
+ * One rectangle may be another candidate than another by virtue of being exclusively in the beam of the source rect.\r
+ * @param direction The direction (up, down, left, right)\r
+ * @param source The source rect\r
+ * @param rect1 The first rect\r
+ * @param rect2 The second rect\r
+ * @return Whether rect1 is a better candidate than rect2 by virtue of it being in src's beam\r
+ */\r
+static bool BeamBeats(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> rect1, Dali::Rect<float> rect2)\r

 {\r
 {\r

+  const bool rect1InSrcBeam = BeamsOverlap(direction, source, rect1);\r
+  const bool rect2InSrcBeam = BeamsOverlap(direction, source, rect2);\r
+  // if rect1 isn't exclusively in the src beam, it doesn't win\r
+  if(rect2InSrcBeam || !rect1InSrcBeam)\r
+  {\r
+    return false;\r
+  }\r
+  // we know rect1 is in the beam, and rect2 is not\r
+  // if rect1 is to the direction of, and rect2 is not, rect1 wins.\r
+  // for example, for direction left, if rect1 is to the left of the source\r
+  // and rect2 is below, then we always prefer the in beam rect1, since rect2\r
+  // could be reached by going down.\r
+  if(!IsToDirectionOf(direction, source, rect2))\r
+  {\r
+    return true;\r
+  }\r
+  // for horizontal directions, being exclusively in beam always wins\r
+  if((direction == Dali::Toolkit::Control::KeyboardFocus::LEFT || direction == Dali::Toolkit::Control::KeyboardFocus::RIGHT))\r
+  {\r
+    return true;\r
+  }\r
+  // for vertical directions, beams only beat up to a point:\r
+  // now, as long as rect2 isn't completely closer, rect1 wins\r
+  // e.g for direction down, completely closer means for rect2's top\r
+  // edge to be closer to the source's top edge than rect1's bottom edge.\r
+  return (MajorAxisDistance(direction, source, rect1) < MajorAxisDistanceToFarEdge(direction, source, rect2));\r

 }\r
 \r
 }\r
 \r

-Actor FocusFinder::GetNearestFocusableActor(Actor focusedActor, Toolkit::Control::KeyboardFocus::Direction direction)\r
+bool IsBetterCandidate(Toolkit::Control::KeyboardFocus::Direction direction, Rect<float>& focusedRect, Rect<float>& candidateRect, Rect<float>& bestCandidateRect)\r

 {\r
 {\r

-  return GetImpl(*this).GetNearestFocusableActor(focusedActor, direction);\r
+  // to be a better candidate, need to at least be a candidate in the first place\r
+  if(!IsCandidate(focusedRect, candidateRect, direction))\r
+  {\r
+    return false;\r
+  }\r
+  // we know that candidateRect is a candidate.. if bestCandidateRect is not a candidate,\r
+  // candidateRect is better\r
+  if(!IsCandidate(focusedRect, bestCandidateRect, direction))\r
+  {\r
+    return true;\r
+  }\r
+  // if candidateRect is better by beam, it wins\r
+  if(BeamBeats(direction, focusedRect, candidateRect, bestCandidateRect))\r
+  {\r
+    return true;\r
+  }\r
+  // if bestCandidateRect is better, then candidateRect cant' be :)\r
+  if(BeamBeats(direction, focusedRect, bestCandidateRect, candidateRect))\r
+  {\r
+    return false;\r
+  }\r
+\r
+  // otherwise, do fudge-tastic comparison of the major and minor axis\r
+  return (GetWeightedDistanceFor(\r
+            MajorAxisDistance(direction, focusedRect, candidateRect),\r
+            MinorAxisDistance(direction, focusedRect, candidateRect)) < GetWeightedDistanceFor(MajorAxisDistance(direction, focusedRect, bestCandidateRect),\r
+                                                                                               MinorAxisDistance(direction, focusedRect, bestCandidateRect)));\r

 }\r
 \r
 }\r
 \r

+Actor FindNextFocus(Actor& actor, Actor& focusedActor, Rect<float>& focusedRect, Rect<float>& bestCandidateRect, Toolkit::Control::KeyboardFocus::Direction direction)\r
+{\r
+  Actor nearestActor;\r
+  if(actor)\r
+  {\r
+    // Recursively children\r
+    const auto childCount = actor.GetChildCount();\r
+    for(auto i = 0u; i < childCount; ++i)\r
+    {\r
+      Dali::Actor child = actor.GetChildAt(i);\r
+      if(child && child != focusedActor && child.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE))\r
+      {\r
+        Rect<float> candidateRect = DevelActor::CalculateScreenExtents(child);\r
+\r
+        // convert x, y, width, height -> left, right, bottom, top\r
+        ConvertCoordinate(candidateRect);\r
+\r
+        if(IsBetterCandidate(direction, focusedRect, candidateRect, bestCandidateRect))\r
+        {\r
+          bestCandidateRect = candidateRect;\r
+          nearestActor      = child;\r
+        }\r
+      }\r
+      Actor nextActor = FindNextFocus(child, focusedActor, focusedRect, bestCandidateRect, direction);\r
+      if(nextActor)\r
+      {\r
+        nearestActor = nextActor;\r
+      }\r
+    }\r
+  }\r
+  return nearestActor;\r
+}\r
+\r
+} // unnamed namespace\r
+\r
+Actor GetNearestFocusableActor(Actor focusedActor, Toolkit::Control::KeyboardFocus::Direction direction)\r
+{\r
+  Actor nearestActor;\r
+  if(!focusedActor)\r
+  {\r
+    return nearestActor;\r
+  }\r
+\r
+  Rect<float> focusedRect = DevelActor::CalculateScreenExtents(focusedActor);\r
+\r
+  // initialize the best candidate to something impossible\r
+  // (so the first plausible actor will become the best choice)\r
+  Rect<float> bestCandidateRect = focusedRect;\r
+  switch(direction)\r
+  {\r
+    case Toolkit::Control::KeyboardFocus::LEFT:\r
+    {\r
+      bestCandidateRect.x += 1;\r
+      break;\r
+    }\r
+    case Toolkit::Control::KeyboardFocus::RIGHT:\r
+    {\r
+      bestCandidateRect.x -= 1;\r
+      break;\r
+    }\r
+    case Toolkit::Control::KeyboardFocus::UP:\r
+    {\r
+      bestCandidateRect.y += 1;\r
+      break;\r
+    }\r
+    case Toolkit::Control::KeyboardFocus::DOWN:\r
+    {\r
+      bestCandidateRect.y -= 1;\r
+      break;\r
+    }\r
+    default:\r
+    {\r
+      break;\r
+    }\r
+  }\r
+\r
+  ConvertCoordinate(bestCandidateRect);\r
+\r
+  ConvertCoordinate(focusedRect);\r
+\r
+  Integration::SceneHolder window = Integration::SceneHolder::Get(focusedActor);\r
+  if(window)\r
+  {\r
+    Actor rootActor = window.GetRootLayer();\r
+    nearestActor    = FindNextFocus(rootActor, focusedActor, focusedRect, bestCandidateRect, direction);\r
+  }\r
+  return nearestActor;\r
+}\r
+\r
+} // namespace FocusFinder\r
+\r

 } // namespace Toolkit\r
 \r
 } // namespace Dali\r
 } // namespace Toolkit\r
 \r
 } // namespace Dali\r

diff --git a/dali-toolkit/devel-api/focus-manager/focus-finder.h b/dali-toolkit/devel-api/focus-manager/focus-finder.h
index 8012675..47f313d 100644 (file)
--- a/dali-toolkit/devel-api/focus-manager/focus-finder.h
+++ b/dali-toolkit/devel-api/focus-manager/focus-finder.h
@@ -25,50 +25,17 @@ namespace Dali
 {\r
 namespace Toolkit\r
 {\r
 {\r
 namespace Toolkit\r
 {\r

-namespace Internal DALI_INTERNAL\r
+namespace FocusFinder\r

 {\r
 {\r

-class FocusFinder;\r
-}\r
-\r

 /**\r
 /**\r

- * FocusFinder\r
- * This class used for finding the next focusable actor in a given direction\r
- * from a actor that currently has focus.\r
+ * Get the nearest focusable actor.\r
+ * @param [in] focusedActor The current focused actor.\r
+ * @param [in] direction The direction.\r
+ * @return The nearest focusable actor, or an empty handle if none exists.\r

  */\r
  */\r

-class DALI_TOOLKIT_API FocusFinder : public BaseHandle\r
-{\r
-public:\r
-  /**\r
-   * Create a FocusFinder handle; this can be initialised with FocusFinder::Get()\r
-   * Calling member functions with an uninitialised handle is not allowed.\r
-   */\r
-  FocusFinder();\r
-\r
-  /**\r
-   * @brief Destructor\r
-   *\r
-   * This is non-virtual since derived Handle types must not contain data or virtual methods.\r
-   */\r
-  ~FocusFinder();\r
-\r
-  /**\r
-   * @brief Get the singleton of FocusFinder object.\r
-   * @return A handle to the FocusFinder control.\r
-   */\r
-  static FocusFinder Get();\r
-\r
-  /**\r
-   * Get the nearest focusable actor.\r
-   * @param [in] focusedActor The current focused actor.\r
-   * @param [in] direction The direction.\r
-   * @return The nearest focusable actor, or null if none exists.\r
-   */\r
-  Actor GetNearestFocusableActor(Actor focusedActor, Toolkit::Control::KeyboardFocus::Direction direction);\r
-\r
-private:\r
-  explicit DALI_INTERNAL FocusFinder(Internal::FocusFinder* impl);\r
+DALI_TOOLKIT_API Actor GetNearestFocusableActor(Actor focusedActor, Toolkit::Control::KeyboardFocus::Direction direction);\r

 \r
 \r

-}; // class FocusFinder\r
+} // namespace FocusFinder\r

 \r
 } // namespace Toolkit\r
 \r
 \r
 } // namespace Toolkit\r
 \r

diff --git a/dali-toolkit/internal/file.list b/dali-toolkit/internal/file.list
index 30435f8..eca4322 100644 (file)
--- a/dali-toolkit/internal/file.list
+++ b/dali-toolkit/internal/file.list
@@ -114,7 +114,6 @@ SET( toolkit_src_files
 
    ${toolkit_src_dir}/focus-manager/keyboard-focus-manager-impl.cpp
    ${toolkit_src_dir}/focus-manager/keyinput-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}/focus-manager/focus-finder-impl.cpp

    ${toolkit_src_dir}/helpers/color-conversion.cpp
    ${toolkit_src_dir}/helpers/property-helper.cpp
    ${toolkit_src_dir}/filters/blur-two-pass-filter.cpp
    ${toolkit_src_dir}/helpers/color-conversion.cpp
    ${toolkit_src_dir}/helpers/property-helper.cpp
    ${toolkit_src_dir}/filters/blur-two-pass-filter.cpp

diff --git a/dali-toolkit/internal/focus-manager/focus-finder-impl.cpp b/dali-toolkit/internal/focus-manager/focus-finder-impl.cpp
deleted file mode 100644 (file)
index 93f1d65..0000000
--- a/dali-toolkit/internal/focus-manager/focus-finder-impl.cpp
+++ /dev/null
@@ -1,449 +0,0 @@
-/*\r
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- *\r
- */\r
-\r
-/*\r
- * Copyright (C) 2017 The Android Open Source Project\r
- *\r
- * Modified by joogab yun(joogab.yun@samsung.com)\r
- */\r
-\r
-// CLASS HEADER\r
-#include "focus-finder-impl.h"\r
-\r
-// INTERNAL INCLUDES\r
-#include <dali/devel-api/actors/actor-devel.h>\r
-\r
-// EXTERNAL INCLUDES\r
-#include <dali/integration-api/adaptor-framework/adaptor.h>\r
-#include <dali/integration-api/adaptor-framework/scene-holder.h>\r
-#include <dali/integration-api/debug.h>\r
-#include <dali/public-api/actors/layer.h>\r
-#include <math.h>\r
-\r
-namespace\r
-{\r
-static int MajorAxisDistanceRaw(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
-{\r
-  switch(direction)\r
-  {\r
-    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
-    {\r
-      return source.left - dest.right;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
-    {\r
-      return dest.left - source.right;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
-    {\r
-      return source.top - dest.bottom;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
-    {\r
-      return dest.top - source.bottom;\r
-    }\r
-    default:\r
-    {\r
-      return 0;\r
-    }\r
-  }\r
-}\r
-\r
-/**\r
- * @return The distance from the edge furthest in the given direction\r
- *   of source to the edge nearest in the given direction of dest.\r
- *   If the dest is not in the direction from source, return 0.\r
- */\r
-static int MajorAxisDistance(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
-{\r
-  return std::max(0, MajorAxisDistanceRaw(direction, source, dest));\r
-}\r
-\r
-static int MajorAxisDistanceToFarEdgeRaw(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
-{\r
-  switch(direction)\r
-  {\r
-    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
-    {\r
-      return source.left - dest.left;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
-    {\r
-      return dest.right - source.right;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
-    {\r
-      return source.top - dest.top;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
-    {\r
-      return dest.bottom - source.bottom;\r
-    }\r
-    default:\r
-    {\r
-      return 0;\r
-    }\r
-  }\r
-}\r
-\r
-/**\r
- * @return The distance along the major axis w.r.t the direction from the\r
- *   edge of source to the far edge of dest.\r
- *   If the dest is not in the direction from source, return 1\r
- */\r
-static int MajorAxisDistanceToFarEdge(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
-{\r
-  return std::max(1, MajorAxisDistanceToFarEdgeRaw(direction, source, dest));\r
-}\r
-\r
-/**\r
- * Find the distance on the minor axis w.r.t the direction to the nearest\r
- * edge of the destination rectangle.\r
- * @param direction the direction (up, down, left, right)\r
- * @param source The source rect.\r
- * @param dest The destination rect.\r
- * @return The distance.\r
- */\r
-static int MinorAxisDistance(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
-{\r
-  switch(direction)\r
-  {\r
-    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
-    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
-    {\r
-      // the distance between the center verticals\r
-      return std::abs(\r
-        (((source.top + source.bottom) * 0.5f) -\r
-         (((dest.top + dest.bottom) * 0.5f))));\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
-    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
-    {\r
-      // the distance between the center horizontals\r
-      return std::abs(\r
-        (((source.left + source.right) * 0.5f) -\r
-         (((dest.left + dest.right) * 0.5f))));\r
-    }\r
-    default:\r
-    {\r
-      return 0;\r
-    }\r
-  }\r
-}\r
-\r
-/**\r
- * Calculate distance given major and minor axis distances.\r
- * @param majorAxisDistance The majorAxisDistance\r
- * @param minorAxisDistance The minorAxisDistance\r
- * @return The distance\r
- */\r
-static int GetWeightedDistanceFor(int majorAxisDistance, int minorAxisDistance)\r
-{\r
-  return 13 * majorAxisDistance * majorAxisDistance + minorAxisDistance * minorAxisDistance;\r
-}\r
-\r
-/**\r
- * Convert x,y,width,height coordinates into left, right, bottom, top coordinates.\r
- * @param[in,out] rect The rect\r
- */\r
-static void ConvertCoordinate(Dali::Rect<float>& rect)\r
-{\r
-  // convert x, y, width, height -> left, right, bottom, top\r
-  float left   = rect.x;\r
-  float right  = rect.x + rect.width;\r
-  float bottom = rect.y + rect.height;\r
-  float top    = rect.y;\r
-\r
-  rect.left   = left;\r
-  rect.right  = right;\r
-  rect.bottom = bottom;\r
-  rect.top    = top;\r
-}\r
-\r
-/**\r
- * Is destRect a candidate for the next focus given the direction?\r
- * @param srcRect The source rect.\r
- * @param destRect The dest rect.\r
- * @param direction The direction (up, down, left, right)\r
- * @return Whether destRect is a candidate.\r
- */\r
-static bool IsCandidate(Dali::Rect<float> srcRect, Dali::Rect<float> destRect, Dali::Toolkit::Control::KeyboardFocus::Direction direction)\r
-{\r
-  switch(direction)\r
-  {\r
-    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
-    {\r
-      return (srcRect.right > destRect.right || srcRect.left >= destRect.right) && srcRect.left > destRect.left;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
-    {\r
-      return (srcRect.left < destRect.left || srcRect.right <= destRect.left) && srcRect.right < destRect.right;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
-    {\r
-      return (srcRect.bottom > destRect.bottom || srcRect.top >= destRect.bottom) && srcRect.top > destRect.top;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
-    {\r
-      return (srcRect.top < destRect.top || srcRect.bottom <= destRect.top) && srcRect.bottom < destRect.bottom;\r
-    }\r
-    default:\r
-    {\r
-      return false;\r
-    }\r
-  }\r
-  return false;\r
-}\r
-\r
-/**\r
- * Is dest in a given direction from src?\r
- * @param direction the direction (up, down, left, right)\r
- * @param src The source rect\r
- * @param dest The dest rect\r
- */\r
-static bool IsToDirectionOf(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> src, Dali::Rect<float> dest)\r
-{\r
-  switch(direction)\r
-  {\r
-    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
-    {\r
-      return src.left >= dest.right;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
-    {\r
-      return src.right <= dest.left;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
-    {\r
-      return src.top >= dest.bottom;\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
-    {\r
-      return src.bottom <= dest.top;\r
-    }\r
-    default:\r
-    {\r
-      return false;\r
-    }\r
-  }\r
-}\r
-\r
-/**\r
- * Do the given direction's axis of rect1 and rect2 overlap?\r
- * @param direction the direction (up, down, left, right)\r
- * @param rect1 The first rect\r
- * @param rect2 The second rect\r
- * @return whether the beams overlap\r
- */\r
-static bool BeamsOverlap(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> rect1, Dali::Rect<float> rect2)\r
-{\r
-  switch(direction)\r
-  {\r
-    case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
-    case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
-    {\r
-      return (rect2.bottom >= rect1.top) && (rect2.top <= rect1.bottom);\r
-    }\r
-    case Dali::Toolkit::Control::KeyboardFocus::UP:\r
-    case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
-    {\r
-      return (rect2.right >= rect1.left) && (rect2.left <= rect1.right);\r
-    }\r
-    default:\r
-    {\r
-      return false;\r
-    }\r
-  }\r
-}\r
-\r
-/**\r
- * One rectangle may be another candidate than another by virtue of being exclusively in the beam of the source rect.\r
- * @param direction The direction (up, down, left, right)\r
- * @param source The source rect\r
- * @param rect1 The first rect\r
- * @param rect2 The second rect\r
- * @return Whether rect1 is a better candidate than rect2 by virtue of it being in src's beam\r
- */\r
-static bool BeamBeats(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> rect1, Dali::Rect<float> rect2)\r
-{\r
-  const bool rect1InSrcBeam = BeamsOverlap(direction, source, rect1);\r
-  const bool rect2InSrcBeam = BeamsOverlap(direction, source, rect2);\r
-  // if rect1 isn't exclusively in the src beam, it doesn't win\r
-  if(rect2InSrcBeam || !rect1InSrcBeam)\r
-  {\r
-    return false;\r
-  }\r
-  // we know rect1 is in the beam, and rect2 is not\r
-  // if rect1 is to the direction of, and rect2 is not, rect1 wins.\r
-  // for example, for direction left, if rect1 is to the left of the source\r
-  // and rect2 is below, then we always prefer the in beam rect1, since rect2\r
-  // could be reached by going down.\r
-  if(!IsToDirectionOf(direction, source, rect2))\r
-  {\r
-    return true;\r
-  }\r
-  // for horizontal directions, being exclusively in beam always wins\r
-  if((direction == Dali::Toolkit::Control::KeyboardFocus::LEFT || direction == Dali::Toolkit::Control::KeyboardFocus::RIGHT))\r
-  {\r
-    return true;\r
-  }\r
-  // for vertical directions, beams only beat up to a point:\r
-  // now, as long as rect2 isn't completely closer, rect1 wins\r
-  // e.g for direction down, completely closer means for rect2's top\r
-  // edge to be closer to the source's top edge than rect1's bottom edge.\r
-  return (MajorAxisDistance(direction, source, rect1) < MajorAxisDistanceToFarEdge(direction, source, rect2));\r
-}\r
-\r
-} // unnamed namespace\r
-\r
-namespace Dali\r
-{\r
-namespace Toolkit\r
-{\r
-namespace Internal\r
-{\r
-FocusFinder::FocusFinder()\r
-{\r
-}\r
-\r
-FocusFinder::~FocusFinder()\r
-{\r
-}\r
-\r
-Actor FocusFinder::GetNearestFocusableActor(Actor& focusedActor, Toolkit::Control::KeyboardFocus::Direction direction)\r
-{\r
-  Actor nearestActor;\r
-  if(!focusedActor)\r
-  {\r
-    return nearestActor;\r
-  }\r
-\r
-  Rect<float> focusedRect = DevelActor::CalculateScreenExtents(focusedActor);\r
-\r
-  // initialize the best candidate to something impossible\r
-  // (so the first plausible actor will become the best choice)\r
-  Rect<float> bestCandidateRect = focusedRect;\r
-  switch(direction)\r
-  {\r
-    case Toolkit::Control::KeyboardFocus::LEFT:\r
-    {\r
-      bestCandidateRect.x += 1;\r
-      break;\r
-    }\r
-    case Toolkit::Control::KeyboardFocus::RIGHT:\r
-    {\r
-      bestCandidateRect.x -= 1;\r
-      break;\r
-    }\r
-    case Toolkit::Control::KeyboardFocus::UP:\r
-    {\r
-      bestCandidateRect.y += 1;\r
-      break;\r
-    }\r
-    case Toolkit::Control::KeyboardFocus::DOWN:\r
-    {\r
-      bestCandidateRect.y -= 1;\r
-      break;\r
-    }\r
-    default:\r
-    {\r
-      break;\r
-    }\r
-  }\r
-\r
-  ConvertCoordinate(bestCandidateRect);\r
-\r
-  ConvertCoordinate(focusedRect);\r
-\r
-  Integration::SceneHolder window = Integration::SceneHolder::Get(focusedActor);\r
-  if(window)\r
-  {\r
-    Actor rootActor = window.GetRootLayer();\r
-    nearestActor    = FindNextFocus(rootActor, focusedActor, focusedRect, bestCandidateRect, direction);\r
-  }\r
-  return nearestActor;\r
-}\r
-\r
-Actor FocusFinder::FindNextFocus(Actor& actor, Actor& focusedActor, Rect<float>& focusedRect, Rect<float>& bestCandidateRect, Toolkit::Control::KeyboardFocus::Direction direction)\r
-{\r
-  Actor nearestActor;\r
-  if(actor)\r
-  {\r
-    // Recursively children\r
-    const auto childCount = actor.GetChildCount();\r
-    for(auto i = 0u; i < childCount; ++i)\r
-    {\r
-      Dali::Actor child = actor.GetChildAt(i);\r
-      if(child && child != focusedActor && child.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE))\r
-      {\r
-        Rect<float> candidateRect = DevelActor::CalculateScreenExtents(child);\r
-\r
-        // convert x, y, width, height -> left, right, bottom, top\r
-        ConvertCoordinate(candidateRect);\r
-\r
-        if(IsBetterCandidate(direction, focusedRect, candidateRect, bestCandidateRect))\r
-        {\r
-          bestCandidateRect = candidateRect;\r
-          nearestActor      = child;\r
-        }\r
-      }\r
-      Actor nextActor = FindNextFocus(child, focusedActor, focusedRect, bestCandidateRect, direction);\r
-      if(nextActor)\r
-      {\r
-        nearestActor = nextActor;\r
-      }\r
-    }\r
-  }\r
-  return nearestActor;\r
-}\r
-\r
-bool FocusFinder::IsBetterCandidate(Toolkit::Control::KeyboardFocus::Direction direction, Rect<float>& focusedRect, Rect<float>& candidateRect, Rect<float>& bestCandidateRect) const\r
-{\r
-  // to be a better candidate, need to at least be a candidate in the first place\r
-  if(!IsCandidate(focusedRect, candidateRect, direction))\r
-  {\r
-    return false;\r
-  }\r
-  // we know that candidateRect is a candidate.. if bestCandidateRect is not a candidate,\r
-  // candidateRect is better\r
-  if(!IsCandidate(focusedRect, bestCandidateRect, direction))\r
-  {\r
-    return true;\r
-  }\r
-  // if candidateRect is better by beam, it wins\r
-  if(BeamBeats(direction, focusedRect, candidateRect, bestCandidateRect))\r
-  {\r
-    return true;\r
-  }\r
-  // if bestCandidateRect is better, then candidateRect cant' be :)\r
-  if(BeamBeats(direction, focusedRect, bestCandidateRect, candidateRect))\r
-  {\r
-    return false;\r
-  }\r
-\r
-  // otherwise, do fudge-tastic comparison of the major and minor axis\r
-  return (GetWeightedDistanceFor(\r
-            MajorAxisDistance(direction, focusedRect, candidateRect),\r
-            MinorAxisDistance(direction, focusedRect, candidateRect)) < GetWeightedDistanceFor(MajorAxisDistance(direction, focusedRect, bestCandidateRect),\r
-                                                                                               MinorAxisDistance(direction, focusedRect, bestCandidateRect)));\r
-}\r
-\r
-} // namespace Internal\r
-\r
-} // namespace Toolkit\r
-\r
-} // namespace Dali\r

diff --git a/dali-toolkit/internal/focus-manager/focus-finder-impl.h b/dali-toolkit/internal/focus-manager/focus-finder-impl.h
deleted file mode 100644 (file)
index 012b1aa..0000000
--- a/dali-toolkit/internal/focus-manager/focus-finder-impl.h
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef DALI_TOOLKIT_INTERNAL_FOCUS_FINDER_H\r
-#define DALI_TOOLKIT_INTERNAL_FOCUS_FINDER_H\r
-\r
-/*\r
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- *\r
- */\r
-\r
-// EXTERNAL INCLUDES\r
-#include <dali/public-api/object/base-object.h>\r
-\r
-// INTERNAL INCLUDES\r
-#include <dali-toolkit/devel-api/focus-manager/focus-finder.h>\r
-\r
-namespace Dali\r
-{\r
-namespace Integration\r
-{\r
-class SceneHolder;\r
-\r
-} // namespace Integration\r
-\r
-namespace Toolkit\r
-{\r
-namespace Internal\r
-{\r
-class FocusFinder;\r
-\r
-/**\r
- * @copydoc Toolkit::FocusFinder\r
- */\r
-class FocusFinder : public Dali::BaseObject\r
-{\r
-public:\r
-  /**\r
-   * Construct a new FocusFinder.\r
-   */\r
-  FocusFinder();\r
-\r
-  /**\r
-   * @copydoc Toolkit::GetNearestFocusableActor\r
-   */\r
-  Actor GetNearestFocusableActor(Actor& focusedActor, Toolkit::Control::KeyboardFocus::Direction direction);\r
-\r
-protected:\r
-  /**\r
-   * Destructor\r
-   */\r
-  virtual ~FocusFinder();\r
-\r
-private:\r
-  /**\r
-   * Find the next actor to take focus in root's descendants, starting from the actor.\r
-   * @param[in] actor The root actor.\r
-   * @param[in] focusedActor The current focused actor.\r
-   * @param[in] focusedRect The rect of current focused actor.\r
-   * @param[in] bestCandidateRect The current best candidate.\r
-   * @param[in] direction The direction.\r
-   * @return nearest Actor.\r
-   */\r
-  Actor FindNextFocus(Actor& actor, Actor& focusedActor, Rect<float>& focusedRect, Rect<float>& bestCandidateRect, Toolkit::Control::KeyboardFocus::Direction direction);\r
-\r
-  /**\r
-   * Is rect1 a better candidate than rect2 for a focus search in a particular\r
-   * direction from a source rect?  This is the core routine that determines\r
-   * the order of focus searching.\r
-   * @param direction The direction (up, down, left, right)\r
-   * @param candidateRect The candidate rectangle\r
-   * @param bestCandidateRect The current best candidate.\r
-   * @return Whether the candidate is the new best.\r
-   */\r
-  bool IsBetterCandidate(Toolkit::Control::KeyboardFocus::Direction direction, Rect<float>& focusedRect, Rect<float>& candidateRect, Rect<float>& bestCandidateRect) const;\r
-\r
-private:\r
-  // Undefined\r
-  FocusFinder(const FocusFinder&);\r
-\r
-  FocusFinder& operator=(const FocusFinder& rhs);\r
-};\r
-\r
-} // namespace Internal\r
-\r
-inline Internal::FocusFinder& GetImpl(Dali::Toolkit::FocusFinder& obj)\r
-{\r
-  DALI_ASSERT_ALWAYS(obj);\r
-\r
-  Dali::BaseObject& handle = obj.GetBaseObject();\r
-\r
-  return static_cast<Internal::FocusFinder&>(handle);\r
-}\r
-\r
-inline const Internal::FocusFinder& GetImpl(const Dali::Toolkit::FocusFinder& obj)\r
-{\r
-  DALI_ASSERT_ALWAYS(obj);\r
-\r
-  const Dali::BaseObject& handle = obj.GetBaseObject();\r
-\r
-  return static_cast<const Internal::FocusFinder&>(handle);\r
-}\r
-\r
-} // namespace Toolkit\r
-\r
-} // namespace Dali\r
-\r
-#endif // DALI_TOOLKIT_INTERNAL_FOCUS_FINDER_H\r

diff --git a/dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.cpp b/dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.cpp
index 0aa9ed1..8dadb11 100644 (file)
--- a/dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.cpp
+++ b/dali-toolkit/internal/focus-manager/keyboard-focus-manager-impl.cpp
@@ -500,7 +500,7 @@ bool KeyboardFocusManager::MoveFocus(Toolkit::Control::KeyboardFocus::Direction
       else
       {
         // We should find it among the actors nearby.
       else
       {
         // We should find it among the actors nearby.

-        nextFocusableActor = Toolkit::FocusFinder::Get().GetNearestFocusableActor(currentFocusActor, direction);
+        nextFocusableActor = Toolkit::FocusFinder::GetNearestFocusableActor(currentFocusActor, direction);

       }
     }
 
       }
     }