dali-toolkit/internal/accessibility-manager/accessibility-manager-impl.h

   1 #ifndef DALI_TOOLKIT_INTERNAL_ACCESSIBILITY_MANAGER_H
   2 #define DALI_TOOLKIT_INTERNAL_ACCESSIBILITY_MANAGER_H
   3
   4 /*
   5  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <string>
  23 #include <dali/devel-api/common/map-wrapper.h>
  24 #include <dali/devel-api/adaptor-framework/accessibility-action-handler.h>
  25 #include <dali/devel-api/adaptor-framework/accessibility-gesture-handler.h>
  26 #include <dali/devel-api/adaptor-framework/accessibility-gesture-event.h>
  27 #include <dali/public-api/object/base-object.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
  31 #include <dali/public-api/adaptor-framework/tts-player.h>
  32
  33 namespace Dali
  34 {
  35
  36 namespace Toolkit
  37 {
  38
  39 namespace Internal
  40 {
  41
  42 class AccessibilityManager;
  43
  44 /**
  45  * @copydoc Toolkit::AccessibilityManager
  46  */
  47 class AccessibilityManager : public Dali::BaseObject, Dali::AccessibilityActionHandler, Dali::AccessibilityGestureHandler, public Dali::ConnectionTracker
  48 {
  49 public:
  50
  51   typedef Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType       AccessibilityActionSignalType;
  52   typedef Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType AccessibilityActionScrollSignalType;
  53
  54   struct ActorAdditionalInfo
  55   {
  56     ActorAdditionalInfo()
  57     : mFocusOrder(0)
  58     {
  59     }
  60
  61     unsigned int mFocusOrder; ///< The focus order of the actor. It is undefined by default.
  62
  63     std::string mAccessibilityAttributes[Toolkit::AccessibilityManager::ACCESSIBILITY_ATTRIBUTE_NUM]; ///< The array of attribute texts
  64   };
  65
  66   typedef std::pair<unsigned int, unsigned int>        FocusIDPair;
  67   typedef std::map<unsigned int, unsigned int>         FocusIDContainer;
  68   typedef FocusIDContainer::iterator                   FocusIDIter;
  69   typedef FocusIDContainer::const_iterator             FocusIDConstIter;
  70
  71   typedef std::pair<unsigned int, ActorAdditionalInfo> IDAdditionalInfoPair;
  72   typedef std::map<unsigned int, ActorAdditionalInfo>  IDAdditionalInfoContainer;
  73   typedef IDAdditionalInfoContainer::iterator          IDAdditionalInfoIter;
  74   typedef IDAdditionalInfoContainer::const_iterator    IDAdditionalInfoConstIter;
  75
  76   /**
  77    * Construct a new AccessibilityManager.
  78    */
  79   AccessibilityManager();
  80
  81   /**
  82    * Initialise the AccessibilityManager
  83    */
  84   void Initialise();
  85
  86   /**
  87    * @copydoc Toolkit::AccessibilityManager::SetAccessibilityAttribute
  88    */
  89   void SetAccessibilityAttribute(Actor actor, Toolkit::AccessibilityManager::AccessibilityAttribute type, const std::string& text);
  90
  91   /**
  92    * @copydoc Toolkit::AccessibilityManager::GetAccessibilityAttribute
  93    */
  94   std::string GetAccessibilityAttribute(Actor actor, Toolkit::AccessibilityManager::AccessibilityAttribute type) const;
  95
  96   /**
  97    * @copydoc Toolkit::AccessibilityManager::SetFocusOrder
  98    */
  99   void SetFocusOrder(Actor actor, const unsigned int order);
 100
 101   /**
 102    * @copydoc Toolkit::AccessibilityManager::GetFocusOrder
 103    */
 104   unsigned int GetFocusOrder(Actor actor) const;
 105
 106   /**
 107    * @copydoc Toolkit::AccessibilityManager::GenerateNewFocusOrder
 108    */
 109   unsigned int GenerateNewFocusOrder() const;
 110
 111   /**
 112    * @copydoc Toolkit::AccessibilityManager::GetActorByFocusOrder
 113    */
 114   Actor GetActorByFocusOrder(const unsigned int order);
 115
 116   /**
 117    * @copydoc Toolkit::AccessibilityManager::SetCurrentFocusActor
 118    */
 119   bool SetCurrentFocusActor(Actor actor);
 120
 121   /**
 122    * @copydoc Toolkit::AccessibilityManager::GetCurrentFocusActor
 123    */
 124   Actor GetCurrentFocusActor();
 125
 126   /**
 127    * @copydoc Toolkit::AccessibilityManager::GetCurrentFocusGroup
 128    */
 129   Actor GetCurrentFocusGroup();
 130
 131   /**
 132    * @copydoc Toolkit::AccessibilityManager::GetCurrentFocusOrder
 133    */
 134   unsigned int GetCurrentFocusOrder();
 135
 136   /**
 137    * @copydoc Toolkit::AccessibilityManager::MoveFocusForward
 138    */
 139   bool MoveFocusForward();
 140
 141   /**
 142    * @copydoc Toolkit::AccessibilityManager::MoveFocusBackward
 143    */
 144   bool MoveFocusBackward();
 145
 146   /**
 147    * @copydoc Toolkit::AccessibilityManager::ClearFocus
 148    */
 149   void ClearFocus();
 150
 151   /**
 152    * @copydoc Toolkit::AccessibilityManager::Reset
 153    */
 154   void Reset();
 155
 156   /**
 157    * @copydoc Toolkit::AccessibilityManager::SetFocusGroup
 158    */
 159   void SetFocusGroup(Actor actor, bool isFocusGroup);
 160
 161   /**
 162    * @copydoc Toolkit::AccessibilityManager::IsFocusGroup
 163    */
 164   bool IsFocusGroup(Actor actor) const;
 165
 166   /**
 167    * @copydoc Toolkit::AccessibilityManager::SetGroupMode
 168    */
 169   void SetGroupMode(bool enabled);
 170
 171   /**
 172    * @copydoc Toolkit::AccessibilityManager::GetGroupMode
 173    */
 174   bool GetGroupMode() const;
 175
 176   /**
 177    * @copydoc Toolkit::AccessibilityManager::SetWrapMode
 178    */
 179   void SetWrapMode(bool wrapped);
 180
 181   /**
 182    * @copydoc Toolkit::AccessibilityManager::GetWrapMode
 183    */
 184   bool GetWrapMode() const;
 185
 186   /**
 187    * @copydoc Toolkit::AccessibilityManager::SetFocusIndicatorActor
 188    */
 189   void SetFocusIndicatorActor(Actor indicator);
 190
 191   /**
 192    * @copydoc Toolkit::AccessibilityManager::GetFocusIndicatorActor
 193    */
 194   Actor GetFocusIndicatorActor();
 195
 196   /**
 197    * @copydoc Toolkit::AccessibilityManager::GetFocusGroup
 198    */
 199   Actor GetFocusGroup(Actor actor);
 200
 201   /**
 202    * @copydoc Toolkit::AccessibilityManager::GetReadPosition
 203    */
 204   Vector2 GetReadPosition() const;
 205
 206 public:
 207
 208   /**
 209    * @copydoc Toolkit::AccessibilityManager::FocusChangedSignal()
 210    */
 211   Toolkit::AccessibilityManager::FocusChangedSignalType& FocusChangedSignal();
 212
 213   /**
 214    * @copydoc Toolkit::AccessibilityManager::FocusOvershotSignal()
 215    */
 216   Toolkit::AccessibilityManager::FocusOvershotSignalType& FocusOvershotSignal();
 217
 218   /**
 219    * @copydoc Toolkit::AccessibilityManager::FocusedActorActivatedSignal()
 220    */
 221   Toolkit::AccessibilityManager::FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
 222
 223 public:  // Signals
 224
 225   /**
 226    * @copydoc Dali::Toolkit::AccessibilityManager::StatusChangedSignal
 227    */
 228   AccessibilityActionSignalType& StatusChangedSignal()
 229   {
 230     return mStatusChangedSignal;
 231   }
 232
 233   /**
 234    * @copydoc Dali::Toolkit::AccessibilityManager::AccessibilityAdaptor::ActionNextSignal
 235    */
 236   AccessibilityActionSignalType& ActionNextSignal()
 237   {
 238     return mActionNextSignal;
 239   }
 240
 241   /**
 242    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPreviousSignal
 243    */
 244   AccessibilityActionSignalType& ActionPreviousSignal()
 245   {
 246     return mActionPreviousSignal;
 247   }
 248
 249   /**
 250    * @copydoc Dali::Toolkit::AccessibilityManager::ActionActivateSignal
 251    */
 252   AccessibilityActionSignalType& ActionActivateSignal()
 253   {
 254     return mActionActivateSignal;
 255   }
 256
 257   /**
 258    * @copydoc Dali::Toolkit::AccessibilityManager::ActionOverSignal
 259    */
 260   AccessibilityActionSignalType& ActionOverSignal()
 261   {
 262     return mActionOverSignal;
 263   }
 264
 265   /**
 266    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadSignal
 267    */
 268   AccessibilityActionSignalType& ActionReadSignal()
 269   {
 270     return mActionReadSignal;
 271   }
 272
 273   /**
 274    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadNextSignal
 275    */
 276   AccessibilityActionSignalType& ActionReadNextSignal()
 277   {
 278     return mActionReadNextSignal;
 279   }
 280
 281   /**
 282    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadPreviousSignal
 283    */
 284   AccessibilityActionSignalType& ActionReadPreviousSignal()
 285   {
 286     return mActionReadPreviousSignal;
 287   }
 288
 289   /**
 290    * @copydoc Dali::Toolkit::AccessibilityManager::ActionUpSignal
 291    */
 292   AccessibilityActionSignalType& ActionUpSignal()
 293   {
 294     return mActionUpSignal;
 295   }
 296
 297   /**
 298    * @copydoc Dali::Toolkit::AccessibilityManager::ActionDownSignal
 299    */
 300   AccessibilityActionSignalType& ActionDownSignal()
 301   {
 302     return mActionDownSignal;
 303   }
 304
 305   /**
 306    * @copydoc Dali::Toolkit::AccessibilityManager::ActionClearFocusSignal
 307    */
 308   AccessibilityActionSignalType& ActionClearFocusSignal()
 309   {
 310     return mActionClearFocusSignal;
 311   }
 312
 313   /**
 314    * @copydoc Dali::Toolkit::AccessibilityManager::ActionBackSignal
 315    */
 316   AccessibilityActionSignalType& ActionBackSignal()
 317   {
 318     return mActionBackSignal;
 319   }
 320
 321   /**
 322    * @copydoc Dali::Toolkit::AccessibilityManager::ActionScrollUpSignal
 323    */
 324   AccessibilityActionSignalType& ActionScrollUpSignal()
 325   {
 326     return mActionScrollUpSignal;
 327   }
 328
 329   /**
 330    * @copydoc Dali::Toolkit::AccessibilityManager::ActionScrollDownSignal
 331    */
 332   AccessibilityActionSignalType& ActionScrollDownSignal()
 333   {
 334     return mActionScrollDownSignal;
 335   }
 336
 337   /**
 338    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPageLeftSignal
 339    */
 340   AccessibilityActionSignalType& ActionPageLeftSignal()
 341   {
 342     return mActionPageLeftSignal;
 343   }
 344
 345   /**
 346    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPageRightSignal
 347    */
 348   AccessibilityActionSignalType& ActionPageRightSignal()
 349   {
 350     return mActionPageRightSignal;
 351   }
 352
 353   /**
 354    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPageUpSignal
 355    */
 356   AccessibilityActionSignalType& ActionPageUpSignal()
 357   {
 358     return mActionPageUpSignal;
 359   }
 360
 361   /**
 362    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPageDownSignal
 363    */
 364   AccessibilityActionSignalType& ActionPageDownSignal()
 365   {
 366     return mActionPageDownSignal;
 367   }
 368
 369   /**
 370    * @copydoc Dali::Toolkit::AccessibilityManager::ActionMoveToFirstSignal
 371    */
 372   AccessibilityActionSignalType& ActionMoveToFirstSignal()
 373   {
 374     return mActionMoveToFirstSignal;
 375   }
 376
 377   /**
 378    * @copydoc Dali::Toolkit::AccessibilityManager::ActionMoveToLastSignal
 379    */
 380   AccessibilityActionSignalType& ActionMoveToLastSignal()
 381   {
 382     return mActionMoveToLastSignal;
 383   }
 384
 385   /**
 386    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadFromTopSignal
 387    */
 388   AccessibilityActionSignalType& ActionReadFromTopSignal()
 389   {
 390     return mActionReadFromTopSignal;
 391   }
 392
 393   /**
 394    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadFromNextSignal
 395    */
 396   AccessibilityActionSignalType& ActionReadFromNextSignal()
 397   {
 398     return mActionReadFromNextSignal;
 399   }
 400
 401   /**
 402    * @copydoc Dali::Toolkit::AccessibilityManager::ActionZoomSignal
 403    */
 404   AccessibilityActionSignalType& ActionZoomSignal()
 405   {
 406     return mActionZoomSignal;
 407   }
 408
 409   /**
 410    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadPauseResumeSignal
 411    */
 412   AccessibilityActionSignalType& ActionReadPauseResumeSignal()
 413   {
 414     return mActionReadPauseResumeSignal;
 415   }
 416
 417   /**
 418    * @copydoc Dali::Toolkit::AccessibilityManager::ActionStartStopSignal
 419    */
 420   AccessibilityActionSignalType& ActionStartStopSignal()
 421   {
 422     return mActionStartStopSignal;
 423   }
 424
 425   /**
 426    * @copydoc Dali::Toolkit::AccessibilityManager::ActionScrollSignal
 427    */
 428   AccessibilityActionScrollSignalType& ActionScrollSignal()
 429   {
 430     return mActionScrollSignal;
 431   }
 432
 433 protected:
 434
 435   /**
 436    * Destructor
 437    */
 438   virtual ~AccessibilityManager();
 439
 440 private:
 441
 442   /**
 443    * Get the additional information (e.g. focus order and description) of the given actor.
 444    * @param actorID The ID of the actor to be queried
 445    * @return The additional information of the actor
 446    */
 447   ActorAdditionalInfo GetActorAdditionalInfo(const unsigned int actorID) const;
 448
 449   /**
 450    * Synchronize the actor's additional information to reflect its latest focus order
 451    * @param actorID The ID of the actor
 452    * @param order The focus order of the actor
 453    * @return The additional information of the actor
 454    */
 455   void SynchronizeActorAdditionalInfo(const unsigned int actorID, const unsigned int order);
 456
 457   /**
 458    * Move the focus to the specified actor and send notification for the focus change.
 459    * @param actorID The ID of the actor to be queried
 460    * @return Whether the focus is successful or not
 461    */
 462   bool DoSetCurrentFocusActor(const unsigned int actorID);
 463
 464   /**
 465    * Move the focus to the next actor in the focus chain towards the specified direction.
 466    * @param focusIDIter The iterator pointing to the current focused actor
 467    * @param forward Whether the focus movement is forward or not. The focus movement will be backward if this is false.
 468    * @param wrapped Whether the focus shoule be moved wrapped around or not
 469    * @return Whether the focus is successful or not
 470    */
 471   bool DoMoveFocus(FocusIDIter focusIDIter, bool forward, bool wrapped);
 472
 473   /**
 474    * Activate the actor. If the actor is control, call OnAccessibilityActivated virtual function.
 475    * This function will emit FocusedActorActivatedSignal.
 476    * @param actor The actor to activate
 477    */
 478   void DoActivate(Actor actor);
 479
 480   /**
 481    * Set whether the actor is focusable or not. A focusable property will be registered for
 482    * the actor if not yet.
 483    * @param actor The actor to be focused
 484    * @param focusable Whether the actor is focusable or not
 485    */
 486   void SetFocusable(Actor actor, bool focusable);
 487
 488   /**
 489    * Handle the accessibility pan gesture.
 490    * @param[in]  panEvent  The pan event to be handled.
 491    * @return whether the gesture is handled successfully or not.
 492    */
 493   bool HandlePanGesture(const AccessibilityGestureEvent& panEvent) override;
 494
 495   /**
 496    * Change the accessibility status when Accessibility feature(screen-reader) turned on or off.
 497    * @return whether the status is changed or not.
 498    */
 499   bool ChangeAccessibilityStatus() override;
 500
 501   /**
 502    * Clear the accessibility focus from the current focused actor.
 503    * @return whether the focus is cleared or not.
 504    */
 505   bool ClearAccessibilityFocus() override;
 506
 507   /**
 508    * Perform the accessibility action associated with a scroll event.
 509    * @param touch The touch point (and time) of the event.
 510    * @return whether the focus is cleared or not.
 511    */
 512   bool AccessibilityActionScroll( Dali::TouchEvent& touch ) override;
 513
 514   /**
 515    * Perform the accessibility action to move focus to the previous focusable actor (by one finger flick up).
 516    * @param allowEndFeedback true if end of list feedback should be played when the focus is alread reached to the end
 517    * @return whether the accessibility action is performed or not.
 518    */
 519   bool AccessibilityActionPrevious(bool allowEndFeedback) override;
 520
 521   /**
 522    * Perform the accessibility action to move focus to the next focusable actor (by one finger flick down).
 523    * @param allowEndFeedback true if end of list feedback should be played when the focus is alread reached to the end
 524    * @return whether the accessibility action is performed or not.
 525    */
 526   bool AccessibilityActionNext(bool allowEndFeedback) override;
 527
 528   /**
 529    * Perform the accessibility action to move focus to the previous focusable actor (by one finger flick left).
 530    * @param allowEndFeedback true if end of list feedback should be played when the focus is alread reached to the end
 531    * @return whether the accessibility action is performed or not.
 532    */
 533   bool AccessibilityActionReadPrevious(bool allowEndFeedback) override;
 534
 535   /**
 536    * Perform the accessibility action to move focus to the next focusable actor (by one finger flick right).
 537    * @param allowEndFeedback true if end of list feedback should be played when the focus is alread reached to the end
 538    * @return whether the accessibility action is performed or not.
 539    */
 540   bool AccessibilityActionReadNext(bool allowEndFeedback) override;
 541
 542   /**
 543    * Perform the accessibility action to focus and read the actor (by one finger tap or move).
 544    * @param allowReadAgain true if the action read again the same object (i.e. read action)
 545    *                       false if the action just read when the focus object is changed (i.e. over action)
 546    * @return whether the accessibility action is performed or not.
 547    */
 548   bool AccessibilityActionRead(bool allowReadAgain) override;
 549
 550   /**
 551    * Perform the accessibility action to activate the current focused actor (by one finger double tap).
 552    * @return whether the accessibility action is performed or not.
 553    */
 554   bool AccessibilityActionActivate() override;
 555
 556   /**
 557    * Perform the accessibility action to change the value when the current focused actor is a slider
 558    * (by double finger down and move up and right).
 559    * @return whether the accessibility action is performed or not.
 560    */
 561   bool AccessibilityActionUp() override;
 562
 563   /**
 564    * Perform the accessibility action to change the value when the current focused actor is a slider
 565    * (by double finger down and move down and left).
 566    * @return whether the accessibility action is performed or not.
 567    */
 568   bool AccessibilityActionDown() override;
 569
 570   /**
 571    * Perform the accessibility action to navigate back (by two fingers circle draw).
 572    * @return whether the accessibility action is performed or not.
 573    */
 574   bool AccessibilityActionBack() override;
 575
 576   /**
 577    * Perform the accessibility action to scroll up the list and focus on the first item on the list
 578    * after the scrolling and read the item (by two finger swipe up).
 579    * @return whether the accessibility action is performed or not.
 580    */
 581   bool AccessibilityActionScrollUp() override;
 582
 583   /**
 584    * Perform the accessibility action to scroll down the list and focus on the first item on the list
 585    * after the scrolling and read the item (by two finger swipe down).
 586    * @return whether the accessibility action is performed or not.
 587    */
 588   bool AccessibilityActionScrollDown() override;
 589
 590   /**
 591    * Perform the accessibility action to scroll left to the previous page (by two finger swipe left).
 592    * @return whether the accessibility action is performed or not.
 593    */
 594   bool AccessibilityActionPageLeft() override;
 595
 596   /**
 597    * Perform the accessibility action to scroll right to the next page (by two finger swipe right).
 598    * @return whether the accessibility action is performed or not.
 599    */
 600   bool AccessibilityActionPageRight() override;
 601
 602   /**
 603    * Perform the accessibility action to scroll up to the previous page (by one finger swipe left and right).
 604    * @return whether the accessibility action is performed or not.
 605    */
 606   bool AccessibilityActionPageUp() override;
 607
 608   /**
 609    * Perform the accessibility action to scroll down to the next page (by one finger swipe right and left).
 610    * @return whether the accessibility action is performed or not.
 611    */
 612   bool AccessibilityActionPageDown() override;
 613
 614   /**
 615    * Perform the accessibility action to move the focus to the first item on the screen
 616    * (by one finger swipe up and down).
 617    * @return whether the accessibility action is performed or not.
 618    */
 619   bool AccessibilityActionMoveToFirst() override;
 620
 621   /**
 622    * Perform the accessibility action to move the focus to the last item on the screen
 623    * (by one finger swipe down and up).
 624    * @return whether the accessibility action is performed or not.
 625    */
 626   bool AccessibilityActionMoveToLast() override;
 627
 628   /**
 629    * Perform the accessibility action to move the focus to the first item on the top
 630    * and read from the top item continuously (by three fingers single tap).
 631    * @return whether the accessibility action is performed or not.
 632    */
 633   bool AccessibilityActionReadFromTop() override;
 634
 635   /**
 636    * Perform the accessibility action to move the focus to and read from the next item
 637    * continuously (by three fingers double tap).
 638    * @return whether the accessibility action is performed or not.
 639    */
 640   bool AccessibilityActionReadFromNext() override;
 641
 642   /**
 643    * Perform the accessibility action to move the focus to do the zooming (by one finger triple tap).
 644    * @return whether the accessibility action is performed or not.
 645    */
 646   bool AccessibilityActionZoom() override;
 647
 648   /**
 649    * Perform the accessibility action to pause/resume the current read out (by two fingers single tap).
 650    * @return whether the accessibility action is performed or not.
 651    */
 652   bool AccessibilityActionReadPauseResume() override;
 653
 654   /**
 655    * Perform the accessibility action to start/stop the current action (by two fingers double tap).
 656    * @return whether the accessibility action is performed or not.
 657    */
 658   bool AccessibilityActionStartStop() override;
 659
 660   /**
 661    * This function is connected to the TtsPlayer StateChangeSignal.
 662    * It is called when the TTS players state changes.
 663    * @param previousState The previous state of the TTS player (for comparison)
 664    * @param currentState  The current state of the TTS player
 665    */
 666   void TtsStateChanged( const Dali::TtsPlayer::State previousState, const Dali::TtsPlayer::State currentState );
 667
 668 private:
 669
 670   // Undefined
 671   AccessibilityManager(const AccessibilityManager&);
 672
 673   AccessibilityManager& operator=(const AccessibilityManager& rhs);
 674
 675 private:
 676
 677   Toolkit::AccessibilityManager::FocusChangedSignalType mFocusChangedSignal; ///< The signal to notify the focus change
 678   Toolkit::AccessibilityManager::FocusOvershotSignalType mFocusOvershotSignal; ///< The signal to notify the focus overshooted
 679   Toolkit::AccessibilityManager::FocusedActorActivatedSignalType mFocusedActorActivatedSignal; ///< The signal to notify the activation of focused actor
 680
 681   // Action signals.
 682   AccessibilityActionSignalType       mStatusChangedSignal;
 683   AccessibilityActionSignalType       mActionNextSignal;
 684   AccessibilityActionSignalType       mActionPreviousSignal;
 685   AccessibilityActionSignalType       mActionActivateSignal;
 686   AccessibilityActionSignalType       mActionOverSignal;
 687   AccessibilityActionSignalType       mActionReadSignal;
 688   AccessibilityActionSignalType       mActionReadNextSignal;
 689   AccessibilityActionSignalType       mActionReadPreviousSignal;
 690   AccessibilityActionSignalType       mActionUpSignal;
 691   AccessibilityActionSignalType       mActionDownSignal;
 692   AccessibilityActionSignalType       mActionClearFocusSignal;
 693   AccessibilityActionSignalType       mActionBackSignal;
 694   AccessibilityActionSignalType       mActionScrollUpSignal;
 695   AccessibilityActionSignalType       mActionScrollDownSignal;
 696   AccessibilityActionSignalType       mActionPageLeftSignal;
 697   AccessibilityActionSignalType       mActionPageRightSignal;
 698   AccessibilityActionSignalType       mActionPageUpSignal;
 699   AccessibilityActionSignalType       mActionPageDownSignal;
 700   AccessibilityActionSignalType       mActionMoveToFirstSignal;
 701   AccessibilityActionSignalType       mActionMoveToLastSignal;
 702   AccessibilityActionSignalType       mActionReadFromTopSignal;
 703   AccessibilityActionSignalType       mActionReadFromNextSignal;
 704   AccessibilityActionSignalType       mActionZoomSignal;
 705   AccessibilityActionSignalType       mActionReadPauseResumeSignal;
 706   AccessibilityActionSignalType       mActionStartStopSignal;
 707   AccessibilityActionScrollSignalType mActionScrollSignal;
 708
 709   FocusIDContainer mFocusIDContainer;       ///< The container to look up actor ID by focus order
 710   IDAdditionalInfoContainer mIDAdditionalInfoContainer; ///< The container to look up additional information by actor ID
 711   FocusIDPair mCurrentFocusActor;           ///< The focus order and actor ID of current focused actor
 712   Actor mCurrentGesturedActor;              ///< The actor that will handle the gesture
 713   Actor mFocusIndicatorActor;               ///< The focus indicator actor shared by all the focusable actors for highlight
 714   Vector2 mPreviousPosition;                ///< The previous pan position; useful for calculating velocity for GestureState::FINISHED events
 715   unsigned int mRecursiveFocusMoveCounter;  ///< The counter to count the number of recursive focus movement attempted before the focus movement is successful.
 716   std::string mFocusSoundFilePath;          ///< The path of the focus sound file
 717   std::string mFocusChainEndSoundFilePath;  ///< The path of the focus chain end sound file
 718
 719   bool mIsWrapped:1;                        ///< Whether the focus movement is wrapped around or not
 720   bool mIsFocusWithinGroup:1;               ///< Whether the focus movement is limited to the current focus group or not
 721   bool mIsEndcapFeedbackEnabled:1;          ///< Whether the endcap feedback need to be played when the focus leaves the end or vice versa
 722   bool mIsEndcapFeedbackPlayed:1;           ///< Whether the endcap feedback was played or not
 723   bool mIsAccessibilityTtsEnabled:1;        ///< Whether accessibility feature(screen-reader) turned on/off
 724   bool mTtsCreated:1;                       ///< Whether the TTS Player has been accessed
 725   bool mIsFocusIndicatorEnabled:1;          ///< Whether indicator should be shown / hidden. It could be enabled when TTS enabled or 'Tab' key operated.
 726   bool mContinuousPlayMode:1;               ///< Keeps track of whether or not we are in continuous play mode
 727   bool mIsFocusSoundFilePathSet:1;          ///< Whether the path of the focus sound file has been set
 728   bool mIsFocusChainEndSoundFilePathSet:1;  ///< Whether the path of the focus chain end sound file has been set
 729
 730 };
 731
 732 } // namespace Internal
 733
 734 inline Internal::AccessibilityManager& GetImpl(Dali::Toolkit::AccessibilityManager& obj)
 735 {
 736   DALI_ASSERT_ALWAYS(obj);
 737
 738   Dali::BaseObject& handle = obj.GetBaseObject();
 739
 740   return static_cast<Internal::AccessibilityManager&>(handle);
 741 }
 742
 743 inline const Internal::AccessibilityManager& GetImpl(const Dali::Toolkit::AccessibilityManager& obj)
 744 {
 745   DALI_ASSERT_ALWAYS(obj);
 746
 747   const Dali::BaseObject& handle = obj.GetBaseObject();
 748
 749   return static_cast<const Internal::AccessibilityManager&>(handle);
 750 }
 751
 752 } // namespace Toolkit
 753
 754 } // namespace Dali
 755
 756 #endif // DALI_TOOLKIT_INTERNAL_ACCESSIBILITY_MANAGER_H