80e5c2d91db204cf7c453a28ab4fc5ef218953ff
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / focus-manager / focus-manager-impl.cpp
1 //
2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Flora License, Version 1.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //     http://floralicense.org/license/
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an AS IS BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 // CLASS HEADER
18 #include "focus-manager-impl.h"
19
20 // INTERNAL INCLUDES
21 #include <dali-toolkit/public-api/controls/control.h>
22 #include <dali-toolkit/public-api/controls/control-impl.h>
23 #include <dali/integration-api/debug.h>
24
25 namespace Dali
26 {
27
28 namespace Toolkit
29 {
30
31 namespace Internal
32 {
33
34 namespace // unnamed namespace
35 {
36
37 #if defined(DEBUG_ENABLED)
38 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_FOCUS_MANAGER");
39 #endif
40
41 const char * const ACTOR_FOCUSABLE("focusable");
42 const char * const IS_FOCUS_GROUP("is-focus-group");
43
44 const char* FOCUS_BORDER_IMAGE_PATH = DALI_IMAGE_DIR "B16-8_TTS_focus.png";
45 const Vector4 FOCUS_BORDER_IMAGE_BORDER = Vector4(7.0f, 7.0f, 7.0f, 7.0f);
46
47 /**
48  * The function to be used in the hit-test algorithm to check whether the actor is hittable.
49  */
50 bool IsActorFocusableFunction(Actor actor, Dali::HitTestAlgorithm::TraverseType type)
51 {
52   bool hittable = false;
53
54   switch (type)
55   {
56     case Dali::HitTestAlgorithm::CHECK_ACTOR:
57     {
58       // Check whether the actor is visible and not fully transparent.
59       if( actor.IsVisible()
60        && actor.GetCurrentWorldColor().a > 0.01f) // not FULLY_TRANSPARENT
61       {
62         // Check whether the actor is focusable
63         Property::Index propertyActorFocusable = actor.GetPropertyIndex(ACTOR_FOCUSABLE);
64         if(propertyActorFocusable != Property::INVALID_INDEX)
65         {
66           hittable = actor.GetProperty<bool>(propertyActorFocusable);
67         }
68       }
69       break;
70     }
71     case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
72     {
73       if( actor.IsVisible() ) // Actor is visible, if not visible then none of its children are visible.
74       {
75         hittable = true;
76       }
77       break;
78     }
79     default:
80     {
81       break;
82     }
83   }
84
85   return hittable;
86 };
87
88 }
89
90 FocusManager::FocusManager()
91 : mIsWrapped(false),
92   mIsFocusWithinGroup(false),
93   mCurrentFocusActor(FocusIDPair(0, 0)),
94   mFocusIndicatorActor(Actor()),
95   mRecursiveFocusMoveCounter(0),
96   mIsAccessibilityTtsEnabled(false),
97   mIsFocusIndicatorEnabled(false)
98 {
99   CreateDefaultFocusIndicatorActor();
100
101   AccessibilityManager manager = AccessibilityManager::Get();
102   manager.SetActionHandler(*this);
103   manager.SetGestureHandler(*this);
104
105   ChangeAccessibilityStatus();
106 }
107
108 FocusManager::~FocusManager()
109 {
110 }
111
112 FocusManager::ActorAdditionalInfo FocusManager::GetActorAdditionalInfo(const unsigned int actorID) const
113 {
114   ActorAdditionalInfo data;
115   IDAdditionalInfoConstIter iter = mIDAdditionalInfoContainer.find(actorID);
116   if(iter != mIDAdditionalInfoContainer.end())
117   {
118     data = (*iter).second;
119   }
120
121   return data;
122 }
123
124 void FocusManager::SynchronizeActorAdditionalInfo(const unsigned int actorID, const unsigned int order)
125 {
126   ActorAdditionalInfo actorInfo = GetActorAdditionalInfo(actorID);
127   actorInfo.mFocusOrder = order;
128   mIDAdditionalInfoContainer.erase(actorID);
129   mIDAdditionalInfoContainer.insert(IDAdditionalInfoPair(actorID, actorInfo));
130 }
131
132 void FocusManager::SetAccessibilityAttribute(Actor actor, Toolkit::FocusManager::AccessibilityAttribute type, const std::string& text)
133 {
134   if(actor)
135   {
136     unsigned int actorID = actor.GetId();
137
138     ActorAdditionalInfo info = GetActorAdditionalInfo(actorID);
139     info.mAccessibilityAttributes[type] = text;
140
141     mIDAdditionalInfoContainer.erase(actorID);
142     mIDAdditionalInfoContainer.insert(IDAdditionalInfoPair(actorID, info));
143   }
144 }
145
146 std::string FocusManager::GetAccessibilityAttribute(Actor actor, Toolkit::FocusManager::AccessibilityAttribute type) const
147 {
148   std::string text;
149
150   if(actor)
151   {
152     ActorAdditionalInfo data = GetActorAdditionalInfo(actor.GetId());
153     text = data.mAccessibilityAttributes[type];
154   }
155
156   return text;
157 }
158
159 void FocusManager::SetFocusOrder(Actor actor, const unsigned int order)
160 {
161   // Do nothing if the focus order of the actor is not changed.
162   if(actor && GetFocusOrder(actor) != order)
163   {
164     // Firstly delete the actor from the focus chain if it's already there with a different focus order.
165     mFocusIDContainer.erase(GetFocusOrder(actor));
166
167     // Create actor focusable property if not already created.
168     Property::Index propertyActorFocusable = actor.GetPropertyIndex(ACTOR_FOCUSABLE);
169     if(propertyActorFocusable == Property::INVALID_INDEX)
170     {
171       propertyActorFocusable = actor.RegisterProperty(ACTOR_FOCUSABLE, true);
172     }
173
174     if(order == 0)
175     {
176       // The actor is not focusable without a defined focus order.
177       actor.SetProperty(propertyActorFocusable, false);
178
179       // If the actor is currently being focused, it should clear the focus
180       if(actor == GetCurrentFocusActor())
181       {
182         ClearFocus();
183       }
184     }
185     else // Insert the actor to the focus chain
186     {
187       // Check whether there is another actor in the focus chain with the same focus order already.
188       FocusIDIter focusIDIter = mFocusIDContainer.find(order);
189       if(focusIDIter != mFocusIDContainer.end())
190       {
191         // We need to increase the focus order of that actor and all the actors followed it
192         // in the focus chain.
193         FocusIDIter lastIter = mFocusIDContainer.end();
194         --lastIter;//We want forward iterator to the last element here
195         mFocusIDContainer.insert(FocusIDPair((*lastIter).first + 1, (*lastIter).second));
196
197         // Update the actor's focus order in its additional data
198         SynchronizeActorAdditionalInfo((*lastIter).second, (*lastIter).first + 1);
199
200         for(FocusIDIter iter = lastIter; iter != focusIDIter; iter--)
201         {
202           FocusIDIter previousIter = iter;
203           --previousIter;//We want forward iterator to the previous element here
204           unsigned int actorID = (*previousIter).second;
205           (*iter).second = actorID;
206
207           // Update the actor's focus order in its additional data
208           SynchronizeActorAdditionalInfo(actorID, (*iter).first);
209         }
210
211         mFocusIDContainer.erase(order);
212       }
213
214       // The actor is focusable
215       actor.SetProperty(propertyActorFocusable, true);
216
217       // Now we insert the actor into the focus chain with the specified focus order
218       mFocusIDContainer.insert(FocusIDPair(order, actor.GetId()));
219     }
220
221     // Update the actor's focus order in its additional data
222     SynchronizeActorAdditionalInfo(actor.GetId(), order);
223   }
224 }
225
226 unsigned int FocusManager::GetFocusOrder(Actor actor) const
227 {
228   unsigned int focusOrder = 0;
229
230   if(actor)
231   {
232     ActorAdditionalInfo data = GetActorAdditionalInfo(actor.GetId());
233     focusOrder = data.mFocusOrder;
234   }
235
236   return focusOrder;
237 }
238
239 unsigned int FocusManager::GenerateNewFocusOrder() const
240 {
241   unsigned int order = 1;
242   FocusIDContainer::const_reverse_iterator iter = mFocusIDContainer.rbegin();
243
244   if(iter != mFocusIDContainer.rend())
245   {
246     order = (*iter).first + 1;
247   }
248
249   return order;
250 }
251
252 Actor FocusManager::GetActorByFocusOrder(const unsigned int order)
253 {
254   Actor actor = Actor();
255
256   FocusIDIter focusIDIter = mFocusIDContainer.find(order);
257   if(focusIDIter != mFocusIDContainer.end())
258   {
259     Actor rootActor = Stage::GetCurrent().GetRootLayer();
260     actor = rootActor.FindChildById(mFocusIDContainer[order]);
261   }
262
263   return actor;
264 }
265
266 bool FocusManager::SetCurrentFocusActor(Actor actor)
267 {
268   if(actor)
269   {
270     return DoSetCurrentFocusActor(actor.GetId());
271   }
272
273   return false;
274 }
275
276 bool FocusManager::DoSetCurrentFocusActor(const unsigned int actorID)
277 {
278   Actor rootActor = Stage::GetCurrent().GetRootLayer();
279
280   // If the group mode is enabled, check which focus group the current focused actor belongs to
281   Actor focusGroup;
282   if(mIsFocusWithinGroup)
283   {
284     focusGroup = GetFocusGroup(GetCurrentFocusActor());
285   }
286
287   if(!focusGroup)
288   {
289     focusGroup = rootActor;
290   }
291
292   Actor actor = focusGroup.FindChildById(actorID);
293
294   // Check whether the actor is in the stage
295   if(actor)
296   {
297     // Check whether the actor is focusable
298     bool actorFocusable = false;
299     Property::Index propertyActorFocusable = actor.GetPropertyIndex(ACTOR_FOCUSABLE);
300     if(propertyActorFocusable != Property::INVALID_INDEX)
301     {
302       actorFocusable = actor.GetProperty<bool>(propertyActorFocusable);
303     }
304
305     // Go through the actor's hierarchy to check whether the actor is visible
306     bool actorVisible = actor.IsVisible();
307     Actor parent = actor.GetParent();
308     while (actorVisible && parent && parent != rootActor)
309     {
310       actorVisible = parent.IsVisible();
311       parent = parent.GetParent();
312     }
313
314     // Check whether the actor is fully transparent
315     bool actorOpaque = actor.GetCurrentWorldColor().a > 0.01f;
316
317     // Set the focus only when the actor is focusable and visible and not fully transparent
318     if(actorVisible && actorFocusable && actorOpaque)
319     {
320       // Draw the focus indicator upon the focused actor
321       if(mIsFocusIndicatorEnabled && mFocusIndicatorActor)
322       {
323         actor.Add(mFocusIndicatorActor);
324       }
325
326       // Send notification for the change of focus actor
327       mFocusChangedSignalV2.Emit( GetCurrentFocusActor(), actor );
328
329       // Save the current focused actor
330       mCurrentFocusActor = FocusIDPair(GetFocusOrder(actor), actorID);
331
332       if(mIsAccessibilityTtsEnabled)
333       {
334         // Play the accessibility attributes with the TTS player.
335         Dali::TtsPlayer player = Dali::TtsPlayer::Get(Dali::TtsPlayer::SCREEN_READER);
336
337         // Combine attribute texts to one text
338         std::string informationText;
339         for(int i = 0; i < Toolkit::FocusManager::ACCESSIBILITY_ATTRIBUTE_NUM; i++)
340         {
341           if(!GetActorAdditionalInfo(actorID).mAccessibilityAttributes[i].empty())
342           {
343             if( i > 0 )
344             {
345               informationText += ", "; // for space time between each information
346             }
347             informationText += GetActorAdditionalInfo(actorID).mAccessibilityAttributes[i];
348           }
349         }
350         player.Play(informationText);
351       }
352
353       return true;
354     }
355   }
356
357   DALI_LOG_WARNING("[%s:%d] FAILED\n", __FUNCTION__, __LINE__);
358   return false;
359 }
360
361 Actor FocusManager::GetCurrentFocusActor()
362 {
363   Actor rootActor = Stage::GetCurrent().GetRootLayer();
364   return rootActor.FindChildById(mCurrentFocusActor.second);
365 }
366
367 Actor FocusManager::GetCurrentFocusGroup()
368 {
369   return GetFocusGroup(GetCurrentFocusActor());
370 }
371
372 unsigned int FocusManager::GetCurrentFocusOrder()
373 {
374   return mCurrentFocusActor.first;
375 }
376
377 bool FocusManager::MoveFocusForward()
378 {
379   bool ret = false;
380   mRecursiveFocusMoveCounter = 0;
381
382   FocusIDIter focusIDIter = mFocusIDContainer.find(mCurrentFocusActor.first);
383   if(focusIDIter != mFocusIDContainer.end())
384   {
385     DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] focus order : %d\n", __FUNCTION__, __LINE__, (*focusIDIter).first);
386     ret = DoMoveFocus(focusIDIter, true, mIsWrapped);
387   }
388   else
389   {
390     // TODO: if there is not focused actor, move first actor
391     if(!mFocusIDContainer.empty())
392     {
393       //if there is not focused actor, move 1st actor
394       focusIDIter = mFocusIDContainer.begin(); // TODO: I'm not sure it was sorted.
395       DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] focus order : %d\n", __FUNCTION__, __LINE__, (*focusIDIter).first);
396       ret = DoSetCurrentFocusActor((*focusIDIter).second);
397     }
398   }
399
400   DALI_LOG_INFO( gLogFilter, Debug::General, "[%s] %s\n", __FUNCTION__, ret?"SUCCEED!!!":"FAILED!!!");
401
402   return ret;
403 }
404
405 bool FocusManager::MoveFocusBackward()
406 {
407   bool ret = false;
408   mRecursiveFocusMoveCounter = 0;
409
410   FocusIDIter focusIDIter = mFocusIDContainer.find(mCurrentFocusActor.first);
411   if(focusIDIter != mFocusIDContainer.end())
412   {
413     DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] focus order : %d\n", __FUNCTION__, __LINE__, (*focusIDIter).first);
414     ret = DoMoveFocus(focusIDIter, false, mIsWrapped);
415   }
416   else
417   {
418     // TODO: if there is not focused actor, move last actor
419     if(!mFocusIDContainer.empty())
420     {
421       //if there is not focused actor, move last actor
422       focusIDIter = mFocusIDContainer.end();
423       --focusIDIter;//We want forward iterator to the last element here
424       DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] focus order : %d\n", __FUNCTION__, __LINE__, (*focusIDIter).first);
425       ret = DoSetCurrentFocusActor((*focusIDIter).second);
426     }
427   }
428
429   DALI_LOG_INFO( gLogFilter, Debug::General, "[%s] %s\n", __FUNCTION__, ret?"SUCCEED!!!":"FAILED!!!");
430
431   return ret;
432 }
433
434 void FocusManager::DoActivate(Actor actor)
435 {
436   if(actor)
437   {
438     Dali::Toolkit::Control control = Dali::Toolkit::Control::DownCast(actor);
439     if(control)
440     {
441       // Notify the control that it is activated
442       control.GetImplementation().OnActivated();
443     }
444
445     // Send notification for the activation of focused actor
446     mFocusedActorActivatedSignalV2.Emit(actor);
447   }
448 }
449
450 void FocusManager::ClearFocus()
451 {
452   Actor actor = GetCurrentFocusActor();
453   if(actor)
454   {
455     actor.Remove(mFocusIndicatorActor);
456   }
457
458   mCurrentFocusActor = FocusIDPair(0, 0);
459
460   // Send notification for the change of focus actor
461   mFocusChangedSignalV2.Emit(actor, Actor());
462
463   if(mIsAccessibilityTtsEnabled)
464   {
465     // Stop the TTS playing if any
466     Dali::TtsPlayer player = Dali::TtsPlayer::Get(Dali::TtsPlayer::SCREEN_READER);
467     player.Stop();
468   }
469 }
470
471 void FocusManager::Reset()
472 {
473   ClearFocus();
474   mFocusIDContainer.clear();
475   mIDAdditionalInfoContainer.clear();
476 }
477
478 void FocusManager::SetFocusGroup(Actor actor, bool isFocusGroup)
479 {
480   if(actor)
481   {
482     // Create focus group property if not already created.
483     Property::Index propertyIsFocusGroup = actor.GetPropertyIndex(IS_FOCUS_GROUP);
484     if(propertyIsFocusGroup == Property::INVALID_INDEX)
485     {
486       propertyIsFocusGroup = actor.RegisterProperty(IS_FOCUS_GROUP, isFocusGroup);
487     }
488     else
489     {
490       actor.SetProperty(propertyIsFocusGroup, isFocusGroup);
491     }
492   }
493 }
494
495 bool FocusManager::IsFocusGroup(Actor actor) const
496 {
497   // Check whether the actor is a focus group
498   bool isFocusGroup = false;
499
500   if(actor)
501   {
502     Property::Index propertyIsFocusGroup = actor.GetPropertyIndex(IS_FOCUS_GROUP);
503     if(propertyIsFocusGroup != Property::INVALID_INDEX)
504     {
505       isFocusGroup = actor.GetProperty<bool>(propertyIsFocusGroup);
506     }
507   }
508
509   return isFocusGroup;
510 }
511
512 Actor FocusManager::GetFocusGroup(Actor actor)
513 {
514   // Go through the actor's hierarchy to check which focus group the actor belongs to
515   while (actor && !IsFocusGroup(actor))
516   {
517     actor = actor.GetParent();
518   }
519
520   return actor;
521 }
522
523 void FocusManager::SetGroupMode(bool enabled)
524 {
525   mIsFocusWithinGroup = enabled;
526 }
527
528 bool FocusManager::GetGroupMode() const
529 {
530   return mIsFocusWithinGroup;
531 }
532
533 void FocusManager::SetWrapMode(bool wrapped)
534 {
535   mIsWrapped = wrapped;
536 }
537
538 bool FocusManager::GetWrapMode() const
539 {
540   return mIsWrapped;
541 }
542
543 void FocusManager::SetFocusIndicatorActor(Actor indicator)
544 {
545   mFocusIndicatorActor = indicator;
546 }
547
548 Actor FocusManager::GetFocusIndicatorActor()
549 {
550   return mFocusIndicatorActor;
551 }
552
553 bool FocusManager::DoMoveFocus(FocusIDIter focusIDIter, bool forward, bool wrapped)
554 {
555   DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] %d focusable actors\n", __FUNCTION__, __LINE__, mFocusIDContainer.size());
556   DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] focus order : %d\n", __FUNCTION__, __LINE__, (*focusIDIter).first);
557
558   if( (forward && ++focusIDIter == mFocusIDContainer.end())
559     || (!forward && focusIDIter-- == mFocusIDContainer.begin()) )
560   {
561     if(wrapped)
562     {
563       if(forward)
564       {
565         focusIDIter = mFocusIDContainer.begin();
566       }
567       else
568       {
569         focusIDIter = mFocusIDContainer.end();
570         --focusIDIter;//We want forward iterator to the last element here
571       }
572     }
573     else
574     {
575       DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] Overshot\n", __FUNCTION__, __LINE__);
576       // Send notification for handling overshooted situation
577       mFocusOvershotSignalV2.Emit(GetCurrentFocusActor(), forward ? Toolkit::FocusManager::OVERSHOT_NEXT : Toolkit::FocusManager::OVERSHOT_PREVIOUS);
578
579       return false; // Try to move the focus out of the scope
580     }
581   }
582
583   if((focusIDIter != mFocusIDContainer.end()) && !DoSetCurrentFocusActor((*focusIDIter).second))
584   {
585     mRecursiveFocusMoveCounter++;
586     if(mRecursiveFocusMoveCounter > mFocusIDContainer.size())
587     {
588       // We've attempted to focus all the actors in the whole focus chain and no actor
589       // can be focused successfully.
590
591       DALI_LOG_WARNING("[%s] There is no more focusable actor in %d focus chains\n", __FUNCTION__, mRecursiveFocusMoveCounter);
592
593       return false;
594     }
595     else
596     {
597       return DoMoveFocus(focusIDIter, forward, wrapped);
598     }
599   }
600
601   return true;
602 }
603
604 void FocusManager::SetFocusable(Actor actor, bool focusable)
605 {
606   if(actor)
607   {
608     // Create actor focusable property if not already created.
609     Property::Index propertyActorFocusable = actor.GetPropertyIndex(ACTOR_FOCUSABLE);
610     if(propertyActorFocusable == Property::INVALID_INDEX)
611     {
612       propertyActorFocusable = actor.RegisterProperty(ACTOR_FOCUSABLE, focusable);
613     }
614     else
615     {
616       actor.SetProperty(propertyActorFocusable, focusable);
617     }
618   }
619 }
620
621 void FocusManager::CreateDefaultFocusIndicatorActor()
622 {
623   // Create a focus indicator actor shared by all the focusable actors
624   Image borderImage = Image::New(FOCUS_BORDER_IMAGE_PATH);
625
626   ImageActor focusIndicator = ImageActor::New(borderImage);
627   focusIndicator.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
628   focusIndicator.SetStyle( ImageActor::STYLE_NINE_PATCH );
629   focusIndicator.SetNinePatchBorder(FOCUS_BORDER_IMAGE_BORDER);
630   focusIndicator.SetPosition(Vector3(0.0f, 0.0f, 1.0f));
631
632   // Apply size constraint to the focus indicator
633   Constraint constraint = Constraint::New<Vector3>(Actor::SIZE,
634                                                    ParentSource(Actor::SIZE),
635                                                    EqualToConstraint());
636   focusIndicator.ApplyConstraint(constraint);
637
638   SetFocusIndicatorActor(focusIndicator);
639 }
640
641 bool FocusManager::ChangeAccessibilityStatus()
642 {
643   AccessibilityManager manager = AccessibilityManager::Get();
644   mIsAccessibilityTtsEnabled = manager.IsEnabled();
645
646   if(mIsAccessibilityTtsEnabled)
647   {
648     // Show indicator when tts turned on if there is focused actor.
649     Actor actor = GetCurrentFocusActor();
650     if(actor)
651     {
652       if(mFocusIndicatorActor)
653       {
654         actor.Add(mFocusIndicatorActor);
655       }
656     }
657     mIsFocusIndicatorEnabled = true;
658   }
659   else
660   {
661     // Hide indicator when tts turned off
662     Actor actor = GetCurrentFocusActor();
663     if(actor)
664     {
665       actor.Remove(mFocusIndicatorActor);
666     }
667     mIsFocusIndicatorEnabled = false;
668   }
669
670   return true;
671 }
672
673 bool FocusManager::AccessibilityActionNext()
674 {
675   if(mIsAccessibilityTtsEnabled)
676   {
677     return MoveFocusForward();
678   }
679   else
680   {
681     return false;
682   }
683 }
684
685 bool FocusManager::AccessibilityActionPrevious()
686 {
687   if(mIsAccessibilityTtsEnabled)
688   {
689     return MoveFocusBackward();
690   }
691   else
692   {
693     return false;
694   }
695 }
696
697 bool FocusManager::AccessibilityActionActivate()
698 {
699   bool ret = false;
700
701   Actor actor = GetCurrentFocusActor();
702   if(actor)
703   {
704     DoActivate(actor);
705     ret = true;
706   }
707
708   return ret;
709 }
710
711 bool FocusManager::AccessibilityActionRead(bool allowReadAgain)
712 {
713   bool ret = false;
714
715   if(mIsAccessibilityTtsEnabled)
716   {
717     // Find the focusable actor at the read position
718     AccessibilityManager manager = AccessibilityManager::Get();
719     Dali::HitTestAlgorithm::Results results;
720     Dali::HitTestAlgorithm::HitTest( Stage::GetCurrent(), manager.GetReadPosition(), results, IsActorFocusableFunction );
721
722     FocusIDIter focusIDIter = mFocusIDContainer.find(GetFocusOrder(results.actor));
723     if(focusIDIter != mFocusIDContainer.end())
724     {
725       if( allowReadAgain || (results.actor != GetCurrentFocusActor()) )
726       {
727         // Move the focus to the actor
728         ret = SetCurrentFocusActor(results.actor);
729         DALI_LOG_INFO( gLogFilter, Debug::General, "[%s:%d] SetCurrentFocusActor returns %s\n", __FUNCTION__, __LINE__, ret?"TRUE":"FALSE");
730       }
731     }
732   }
733
734   return ret;
735 }
736
737 bool FocusManager::AccessibilityActionReadNext()
738 {
739   if(mIsAccessibilityTtsEnabled)
740   {
741     return MoveFocusForward();
742   }
743   else
744   {
745     return false;
746   }
747 }
748
749 bool FocusManager::AccessibilityActionReadPrevious()
750 {
751   if(mIsAccessibilityTtsEnabled)
752   {
753     return MoveFocusBackward();
754   }
755   else
756   {
757     return false;
758   }
759 }
760
761 bool FocusManager::AccessibilityActionUp()
762 {
763   bool ret = false;
764
765   if(mIsAccessibilityTtsEnabled)
766   {
767     Actor actor = GetCurrentFocusActor();
768     if(actor)
769     {
770       Dali::Toolkit::Control control = Dali::Toolkit::Control::DownCast(actor);
771       if(control)
772       {
773         // Notify the control that it is activated
774         ret = control.GetImplementation().OnAccessibilityValueChange(true);
775       }
776     }
777   }
778
779   return ret;
780 }
781
782 bool FocusManager::AccessibilityActionDown()
783 {
784   bool ret = false;
785
786   if(mIsAccessibilityTtsEnabled)
787   {
788     Actor actor = GetCurrentFocusActor();
789     if(actor)
790     {
791       Dali::Toolkit::Control control = Dali::Toolkit::Control::DownCast(actor);
792       if(control)
793       {
794         // Notify the control that it is activated
795         ret = control.GetImplementation().OnAccessibilityValueChange(false);
796       }
797     }
798   }
799
800   return ret;
801 }
802
803 bool FocusManager::ClearAccessibilityFocus()
804 {
805   if(mIsAccessibilityTtsEnabled)
806   {
807     ClearFocus();
808     return true;
809   }
810   else
811   {
812     return false;
813   }
814 }
815
816 bool FocusManager::AccessibilityActionBack()
817 {
818   // TODO: Back to previous view
819
820   return mIsAccessibilityTtsEnabled;
821 }
822
823 bool FocusManager::HandlePanGesture(const Integration::PanGestureEvent& panEvent)
824 {
825   bool handled = false;
826
827   Actor currentGesturedActor = GetCurrentFocusActor();
828   Actor rootActor = Stage::GetCurrent().GetRootLayer();
829
830   Dali::PanGesture pan(panEvent.state);
831   pan.time = panEvent.time;
832   pan.numberOfTouches = panEvent.numberOfTouches;
833   pan.screenPosition = panEvent.currentPosition;
834   pan.screenDisplacement = panEvent.previousPosition - panEvent.currentPosition;
835   pan.screenVelocity.x = pan.screenDisplacement.x / panEvent.timeDelta;
836   pan.screenVelocity.y = pan.screenDisplacement.y / panEvent.timeDelta;
837
838   // Only handle the pan gesture when the current focused actor is scrollable or within a scrollable actor
839   while(currentGesturedActor && currentGesturedActor != rootActor && !handled)
840   {
841     Dali::Toolkit::Control control = Dali::Toolkit::Control::DownCast(currentGesturedActor);
842     if(control)
843     {
844       Vector2 localCurrent;
845       control.ScreenToLocal( localCurrent.x, localCurrent.y, panEvent.currentPosition.x, panEvent.currentPosition.y );
846       pan.position = localCurrent;
847
848       Vector2 localPrevious;
849       control.ScreenToLocal( localPrevious.x, localPrevious.y, panEvent.previousPosition.x, panEvent.previousPosition.y );
850
851       pan.displacement = localCurrent - localPrevious;
852       pan.velocity.x = pan.displacement.x / panEvent.timeDelta;
853       pan.velocity.y = pan.displacement.y / panEvent.timeDelta;
854
855       handled = control.GetImplementation().OnAccessibilityPan(pan);
856     }
857
858     // If the gesture is not handled by the control, check its parent
859     if(!handled)
860     {
861       currentGesturedActor = currentGesturedActor.GetParent();
862     }
863     else
864     {
865       // If handled, then update the pan gesture properties
866       PanGestureDetector::SetPanGestureProperties( pan );
867     }
868   }
869
870   return handled;
871 }
872
873 Toolkit::FocusManager::FocusChangedSignalV2& FocusManager::FocusChangedSignal()
874 {
875   return mFocusChangedSignalV2;
876 }
877
878 Toolkit::FocusManager::FocusOvershotSignalV2& FocusManager::FocusOvershotSignal()
879 {
880   return mFocusOvershotSignalV2;
881 }
882
883 Toolkit::FocusManager::FocusedActorActivatedSignalV2& FocusManager::FocusedActorActivatedSignal()
884 {
885   return mFocusedActorActivatedSignalV2;
886 }
887
888 bool FocusManager::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
889 {
890   Dali::BaseHandle handle( object );
891
892   bool connected( true );
893   FocusManager* manager = dynamic_cast<FocusManager*>(object);
894
895   if( Dali::Toolkit::FocusManager::SIGNAL_FOCUS_CHANGED == signalName )
896   {
897     manager->FocusChangedSignal().Connect( tracker, functor );
898   }
899   else if( Dali::Toolkit::FocusManager::SIGNAL_FOCUS_OVERSHOT == signalName )
900   {
901     manager->FocusOvershotSignal().Connect( tracker, functor );
902   }
903   else if( Dali::Toolkit::FocusManager::SIGNAL_FOCUSED_ACTOR_ACTIVATED== signalName )
904   {
905     manager->FocusedActorActivatedSignal().Connect( tracker, functor );
906   }
907   else
908   {
909     // signalName does not match any signal
910     connected = false;
911   }
912
913   return connected;
914 }
915
916 } // namespace Internal
917
918 } // namespace Toolkit
919
920 } // namespace Dali