2679dda7208495a4542444035b6a5c416b3d939e
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / devel-api / focus-manager / focus-finder.cpp
1 /*\r
2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.\r
3  *\r
4  * Licensed under the Apache License, Version 2.0 (the "License");\r
5  * you may not use this file except in compliance with the License.\r
6  * You may obtain a copy of the License at\r
7  *\r
8  * http://www.apache.org/licenses/LICENSE-2.0\r
9  *\r
10  * Unless required by applicable law or agreed to in writing, software\r
11  * distributed under the License is distributed on an "AS IS" BASIS,\r
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
13  * See the License for the specific language governing permissions and\r
14  * limitations under the License.\r
15  *\r
16  */\r
17 \r
18 /*\r
19  * Copyright (C) 2017 The Android Open Source Project\r
20  *\r
21  * Modified by joogab yun(joogab.yun@samsung.com)\r
22  */\r
23 \r
24 // CLASS HEADER\r
25 #include "focus-finder.h"\r
26 \r
27 // EXTERNAL INCLUDES\r
28 #include <dali/devel-api/actors/actor-devel.h>\r
29 #include <dali/integration-api/adaptor-framework/scene-holder.h>\r
30 #include <dali/public-api/actors/layer.h>\r
31 \r
32 namespace Dali\r
33 {\r
34 namespace Toolkit\r
35 {\r
36 namespace FocusFinder\r
37 {\r
38 namespace\r
39 {\r
40 static constexpr float FULLY_TRANSPARENT(0.01f); ///< Alpha values must rise above this, before an object is considered to be visible.\r
41 \r
42 static int MajorAxisDistanceRaw(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
43 {\r
44   switch(direction)\r
45   {\r
46     case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
47     {\r
48       return source.left - dest.right;\r
49     }\r
50     case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
51     {\r
52       return dest.left - source.right;\r
53     }\r
54     case Dali::Toolkit::Control::KeyboardFocus::UP:\r
55     {\r
56       return source.top - dest.bottom;\r
57     }\r
58     case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
59     {\r
60       return dest.top - source.bottom;\r
61     }\r
62     default:\r
63     {\r
64       return 0;\r
65     }\r
66   }\r
67 }\r
68 \r
69 /**\r
70  * @return The distance from the edge furthest in the given direction\r
71  *   of source to the edge nearest in the given direction of dest.\r
72  *   If the dest is not in the direction from source, return 0.\r
73  */\r
74 static int MajorAxisDistance(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
75 {\r
76   return std::max(0, MajorAxisDistanceRaw(direction, source, dest));\r
77 }\r
78 \r
79 static int MajorAxisDistanceToFarEdgeRaw(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
80 {\r
81   switch(direction)\r
82   {\r
83     case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
84     {\r
85       return source.left - dest.left;\r
86     }\r
87     case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
88     {\r
89       return dest.right - source.right;\r
90     }\r
91     case Dali::Toolkit::Control::KeyboardFocus::UP:\r
92     {\r
93       return source.top - dest.top;\r
94     }\r
95     case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
96     {\r
97       return dest.bottom - source.bottom;\r
98     }\r
99     default:\r
100     {\r
101       return 0;\r
102     }\r
103   }\r
104 }\r
105 \r
106 /**\r
107  * @return The distance along the major axis w.r.t the direction from the\r
108  *   edge of source to the far edge of dest.\r
109  *   If the dest is not in the direction from source, return 1\r
110  */\r
111 static int MajorAxisDistanceToFarEdge(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
112 {\r
113   return std::max(1, MajorAxisDistanceToFarEdgeRaw(direction, source, dest));\r
114 }\r
115 \r
116 /**\r
117  * Find the distance on the minor axis w.r.t the direction to the nearest\r
118  * edge of the destination rectangle.\r
119  * @param direction the direction (up, down, left, right)\r
120  * @param source The source rect.\r
121  * @param dest The destination rect.\r
122  * @return The distance.\r
123  */\r
124 static int MinorAxisDistance(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> dest)\r
125 {\r
126   switch(direction)\r
127   {\r
128     case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
129     case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
130     {\r
131       // the distance between the center verticals\r
132       return std::abs((source.top + (source.bottom - source.top) * 0.5f) -\r
133                       (dest.top + (dest.bottom - dest.top) * 0.5f));\r
134     }\r
135     case Dali::Toolkit::Control::KeyboardFocus::UP:\r
136     case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
137     {\r
138       // the distance between the center horizontals\r
139       return std::abs((source.left + (source.right - source.left) * 0.5f) -\r
140                       (dest.left + (dest.right - dest.left) * 0.5f));\r
141     }\r
142     default:\r
143     {\r
144       return 0;\r
145     }\r
146   }\r
147 }\r
148 \r
149 /**\r
150  * Calculate distance given major and minor axis distances.\r
151  * @param majorAxisDistance The majorAxisDistance\r
152  * @param minorAxisDistance The minorAxisDistance\r
153  * @return The distance\r
154  */\r
155 static int GetWeightedDistanceFor(int majorAxisDistance, int minorAxisDistance)\r
156 {\r
157   return 13 * majorAxisDistance * majorAxisDistance + minorAxisDistance * minorAxisDistance;\r
158 }\r
159 \r
160 /**\r
161  * Convert x,y,width,height coordinates into left, right, bottom, top coordinates.\r
162  * @param[in,out] rect The rect\r
163  */\r
164 static void ConvertCoordinate(Dali::Rect<float>& rect)\r
165 {\r
166   // convert x, y, width, height -> left, right, bottom, top\r
167   float left   = rect.x;\r
168   float right  = rect.x + rect.width;\r
169   float bottom = rect.y + rect.height;\r
170   float top    = rect.y;\r
171 \r
172   rect.left   = left;\r
173   rect.right  = right;\r
174   rect.bottom = bottom;\r
175   rect.top    = top;\r
176 }\r
177 \r
178 /**\r
179  * Is destRect a candidate for the next focus given the direction?\r
180  * @param srcRect The source rect.\r
181  * @param destRect The dest rect.\r
182  * @param direction The direction (up, down, left, right)\r
183  * @return Whether destRect is a candidate.\r
184  */\r
185 static bool IsCandidate(Dali::Rect<float> srcRect, Dali::Rect<float> destRect, Dali::Toolkit::Control::KeyboardFocus::Direction direction)\r
186 {\r
187   switch(direction)\r
188   {\r
189     case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
190     {\r
191       return (srcRect.right > destRect.right || srcRect.left >= destRect.right) && srcRect.left > destRect.left;\r
192     }\r
193     case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
194     {\r
195       return (srcRect.left < destRect.left || srcRect.right <= destRect.left) && srcRect.right < destRect.right;\r
196     }\r
197     case Dali::Toolkit::Control::KeyboardFocus::UP:\r
198     {\r
199       return (srcRect.bottom > destRect.bottom || srcRect.top >= destRect.bottom) && srcRect.top > destRect.top;\r
200     }\r
201     case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
202     {\r
203       return (srcRect.top < destRect.top || srcRect.bottom <= destRect.top) && srcRect.bottom < destRect.bottom;\r
204     }\r
205     default:\r
206     {\r
207       return false;\r
208     }\r
209   }\r
210   return false;\r
211 }\r
212 \r
213 /**\r
214  * Is dest in a given direction from src?\r
215  * @param direction the direction (up, down, left, right)\r
216  * @param src The source rect\r
217  * @param dest The dest rect\r
218  */\r
219 static bool IsToDirectionOf(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> src, Dali::Rect<float> dest)\r
220 {\r
221   switch(direction)\r
222   {\r
223     case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
224     {\r
225       return src.left >= dest.right;\r
226     }\r
227     case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
228     {\r
229       return src.right <= dest.left;\r
230     }\r
231     case Dali::Toolkit::Control::KeyboardFocus::UP:\r
232     {\r
233       return src.top >= dest.bottom;\r
234     }\r
235     case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
236     {\r
237       return src.bottom <= dest.top;\r
238     }\r
239     default:\r
240     {\r
241       return false;\r
242     }\r
243   }\r
244 }\r
245 \r
246 /**\r
247  * Do the given direction's axis of rect1 and rect2 overlap?\r
248  * @param direction the direction (up, down, left, right)\r
249  * @param rect1 The first rect\r
250  * @param rect2 The second rect\r
251  * @return whether the beams overlap\r
252  */\r
253 static bool BeamsOverlap(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> rect1, Dali::Rect<float> rect2)\r
254 {\r
255   switch(direction)\r
256   {\r
257     case Dali::Toolkit::Control::KeyboardFocus::LEFT:\r
258     case Dali::Toolkit::Control::KeyboardFocus::RIGHT:\r
259     {\r
260       return (rect2.bottom >= rect1.top) && (rect2.top <= rect1.bottom);\r
261     }\r
262     case Dali::Toolkit::Control::KeyboardFocus::UP:\r
263     case Dali::Toolkit::Control::KeyboardFocus::DOWN:\r
264     {\r
265       return (rect2.right >= rect1.left) && (rect2.left <= rect1.right);\r
266     }\r
267     default:\r
268     {\r
269       return false;\r
270     }\r
271   }\r
272 }\r
273 \r
274 /**\r
275  * One rectangle may be another candidate than another by virtue of being exclusively in the beam of the source rect.\r
276  * @param direction The direction (up, down, left, right)\r
277  * @param source The source rect\r
278  * @param rect1 The first rect\r
279  * @param rect2 The second rect\r
280  * @return Whether rect1 is a better candidate than rect2 by virtue of it being in src's beam\r
281  */\r
282 static bool BeamBeats(Dali::Toolkit::Control::KeyboardFocus::Direction direction, Dali::Rect<float> source, Dali::Rect<float> rect1, Dali::Rect<float> rect2)\r
283 {\r
284   const bool rect1InSrcBeam = BeamsOverlap(direction, source, rect1);\r
285   const bool rect2InSrcBeam = BeamsOverlap(direction, source, rect2);\r
286   // if rect1 isn't exclusively in the src beam, it doesn't win\r
287   if(rect2InSrcBeam || !rect1InSrcBeam)\r
288   {\r
289     return false;\r
290   }\r
291   // we know rect1 is in the beam, and rect2 is not\r
292   // if rect1 is to the direction of, and rect2 is not, rect1 wins.\r
293   // for example, for direction left, if rect1 is to the left of the source\r
294   // and rect2 is below, then we always prefer the in beam rect1, since rect2\r
295   // could be reached by going down.\r
296   if(!IsToDirectionOf(direction, source, rect2))\r
297   {\r
298     return true;\r
299   }\r
300   // for horizontal directions, being exclusively in beam always wins\r
301   if((direction == Dali::Toolkit::Control::KeyboardFocus::LEFT || direction == Dali::Toolkit::Control::KeyboardFocus::RIGHT))\r
302   {\r
303     return true;\r
304   }\r
305   // for vertical directions, beams only beat up to a point:\r
306   // now, as long as rect2 isn't completely closer, rect1 wins\r
307   // e.g for direction down, completely closer means for rect2's top\r
308   // edge to be closer to the source's top edge than rect1's bottom edge.\r
309   return (MajorAxisDistance(direction, source, rect1) < MajorAxisDistanceToFarEdge(direction, source, rect2));\r
310 }\r
311 \r
312 bool IsBetterCandidate(Toolkit::Control::KeyboardFocus::Direction direction, Rect<float>& focusedRect, Rect<float>& candidateRect, Rect<float>& bestCandidateRect)\r
313 {\r
314   // to be a better candidate, need to at least be a candidate in the first place\r
315   if(!IsCandidate(focusedRect, candidateRect, direction))\r
316   {\r
317     return false;\r
318   }\r
319   // we know that candidateRect is a candidate.. if bestCandidateRect is not a candidate,\r
320   // candidateRect is better\r
321   if(!IsCandidate(focusedRect, bestCandidateRect, direction))\r
322   {\r
323     return true;\r
324   }\r
325   // if candidateRect is better by beam, it wins\r
326   if(BeamBeats(direction, focusedRect, candidateRect, bestCandidateRect))\r
327   {\r
328     return true;\r
329   }\r
330   // if bestCandidateRect is better, then candidateRect cant' be :)\r
331   if(BeamBeats(direction, focusedRect, bestCandidateRect, candidateRect))\r
332   {\r
333     return false;\r
334   }\r
335 \r
336   // otherwise, do fudge-tastic comparison of the major and minor axis\r
337   return (GetWeightedDistanceFor(\r
338             MajorAxisDistance(direction, focusedRect, candidateRect),\r
339             MinorAxisDistance(direction, focusedRect, candidateRect)) < GetWeightedDistanceFor(MajorAxisDistance(direction, focusedRect, bestCandidateRect),\r
340                                                                                                MinorAxisDistance(direction, focusedRect, bestCandidateRect)));\r
341 }\r
342 \r
343 bool IsFocusable(Actor& actor)\r
344 {\r
345   return (actor.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE) &&\r
346           actor.GetProperty<bool>(Actor::Property::VISIBLE) &&\r
347           actor.GetProperty<Vector4>(Actor::Property::WORLD_COLOR).a > FULLY_TRANSPARENT);\r
348 }\r
349 \r
350 Actor FindNextFocus(Actor& actor, Actor& focusedActor, Rect<float>& focusedRect, Rect<float>& bestCandidateRect, Toolkit::Control::KeyboardFocus::Direction direction)\r
351 {\r
352   Actor nearestActor;\r
353   if(actor && actor.GetProperty<bool>(Actor::Property::VISIBLE))\r
354   {\r
355     // Recursively children\r
356     const auto childCount = actor.GetChildCount();\r
357     for(auto i = 0u; i < childCount; ++i)\r
358     {\r
359       Dali::Actor child = actor.GetChildAt(i);\r
360       if(child && child != focusedActor && IsFocusable(child))\r
361       {\r
362         Rect<float> candidateRect = DevelActor::CalculateScreenExtents(child);\r
363 \r
364         // convert x, y, width, height -> left, right, bottom, top\r
365         ConvertCoordinate(candidateRect);\r
366 \r
367         if(IsBetterCandidate(direction, focusedRect, candidateRect, bestCandidateRect))\r
368         {\r
369           bestCandidateRect = candidateRect;\r
370           nearestActor      = child;\r
371         }\r
372       }\r
373       Actor nextActor = FindNextFocus(child, focusedActor, focusedRect, bestCandidateRect, direction);\r
374       if(nextActor)\r
375       {\r
376         nearestActor = nextActor;\r
377       }\r
378     }\r
379   }\r
380   return nearestActor;\r
381 }\r
382 \r
383 } // unnamed namespace\r
384 \r
385 Actor GetNearestFocusableActor(Actor focusedActor, Toolkit::Control::KeyboardFocus::Direction direction)\r
386 {\r
387   Actor nearestActor;\r
388   if(!focusedActor)\r
389   {\r
390     return nearestActor;\r
391   }\r
392 \r
393   Rect<float> focusedRect = DevelActor::CalculateScreenExtents(focusedActor);\r
394 \r
395   // initialize the best candidate to something impossible\r
396   // (so the first plausible actor will become the best choice)\r
397   Rect<float> bestCandidateRect = focusedRect;\r
398   switch(direction)\r
399   {\r
400     case Toolkit::Control::KeyboardFocus::LEFT:\r
401     {\r
402       bestCandidateRect.x += 1;\r
403       break;\r
404     }\r
405     case Toolkit::Control::KeyboardFocus::RIGHT:\r
406     {\r
407       bestCandidateRect.x -= 1;\r
408       break;\r
409     }\r
410     case Toolkit::Control::KeyboardFocus::UP:\r
411     {\r
412       bestCandidateRect.y += 1;\r
413       break;\r
414     }\r
415     case Toolkit::Control::KeyboardFocus::DOWN:\r
416     {\r
417       bestCandidateRect.y -= 1;\r
418       break;\r
419     }\r
420     default:\r
421     {\r
422       break;\r
423     }\r
424   }\r
425 \r
426   ConvertCoordinate(bestCandidateRect);\r
427 \r
428   ConvertCoordinate(focusedRect);\r
429 \r
430   Integration::SceneHolder window = Integration::SceneHolder::Get(focusedActor);\r
431   if(window)\r
432   {\r
433     Actor rootActor = window.GetRootLayer();\r
434     nearestActor    = FindNextFocus(rootActor, focusedActor, focusedRect, bestCandidateRect, direction);\r
435   }\r
436   return nearestActor;\r
437 }\r
438 \r
439 } // namespace FocusFinder\r
440 \r
441 } // namespace Toolkit\r
442 \r
443 } // namespace Dali\r