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   /**
 207    * @copydoc Toolkit::AccessibilityManager::EnableAccessibility
 208    */
 209   void EnableAccessibility( bool enabled );
 210
 211   /**
 212    * @copydoc Toolkit::AccessibilityManager::IsEnabled
 213    */
 214   bool IsEnabled() const;
 215
 216 public:
 217
 218   /**
 219    * @copydoc Toolkit::AccessibilityManager::FocusChangedSignal()
 220    */
 221   Toolkit::AccessibilityManager::FocusChangedSignalType& FocusChangedSignal();
 222
 223   /**
 224    * @copydoc Toolkit::AccessibilityManager::FocusOvershotSignal()
 225    */
 226   Toolkit::AccessibilityManager::FocusOvershotSignalType& FocusOvershotSignal();
 227
 228   /**
 229    * @copydoc Toolkit::AccessibilityManager::FocusedActorActivatedSignal()
 230    */
 231   Toolkit::AccessibilityManager::FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
 232
 233 public:  // Signals
 234
 235   /**
 236    * @copydoc Dali::Toolkit::AccessibilityManager::StatusChangedSignal
 237    */
 238   AccessibilityActionSignalType& StatusChangedSignal()
 239   {
 240     return mStatusChangedSignal;
 241   }
 242
 243   /**
 244    * @copydoc Dali::Toolkit::AccessibilityManager::AccessibilityAdaptor::ActionNextSignal
 245    */
 246   AccessibilityActionSignalType& ActionNextSignal()
 247   {
 248     return mActionNextSignal;
 249   }
 250
 251   /**
 252    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPreviousSignal
 253    */
 254   AccessibilityActionSignalType& ActionPreviousSignal()
 255   {
 256     return mActionPreviousSignal;
 257   }
 258
 259   /**
 260    * @copydoc Dali::Toolkit::AccessibilityManager::ActionActivateSignal
 261    */
 262   AccessibilityActionSignalType& ActionActivateSignal()
 263   {
 264     return mActionActivateSignal;
 265   }
 266
 267   /**
 268    * @copydoc Dali::Toolkit::AccessibilityManager::ActionOverSignal
 269    */
 270   AccessibilityActionSignalType& ActionOverSignal()
 271   {
 272     return mActionOverSignal;
 273   }
 274
 275   /**
 276    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadSignal
 277    */
 278   AccessibilityActionSignalType& ActionReadSignal()
 279   {
 280     return mActionReadSignal;
 281   }
 282
 283   /**
 284    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadNextSignal
 285    */
 286   AccessibilityActionSignalType& ActionReadNextSignal()
 287   {
 288     return mActionReadNextSignal;
 289   }
 290
 291   /**
 292    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadPreviousSignal
 293    */
 294   AccessibilityActionSignalType& ActionReadPreviousSignal()
 295   {
 296     return mActionReadPreviousSignal;
 297   }
 298
 299   /**
 300    * @copydoc Dali::Toolkit::AccessibilityManager::ActionUpSignal
 301    */
 302   AccessibilityActionSignalType& ActionUpSignal()
 303   {
 304     return mActionUpSignal;
 305   }
 306
 307   /**
 308    * @copydoc Dali::Toolkit::AccessibilityManager::ActionDownSignal
 309    */
 310   AccessibilityActionSignalType& ActionDownSignal()
 311   {
 312     return mActionDownSignal;
 313   }
 314
 315   /**
 316    * @copydoc Dali::Toolkit::AccessibilityManager::ActionClearFocusSignal
 317    */
 318   AccessibilityActionSignalType& ActionClearFocusSignal()
 319   {
 320     return mActionClearFocusSignal;
 321   }
 322
 323   /**
 324    * @copydoc Dali::Toolkit::AccessibilityManager::ActionBackSignal
 325    */
 326   AccessibilityActionSignalType& ActionBackSignal()
 327   {
 328     return mActionBackSignal;
 329   }
 330
 331   /**
 332    * @copydoc Dali::Toolkit::AccessibilityManager::ActionScrollUpSignal
 333    */
 334   AccessibilityActionSignalType& ActionScrollUpSignal()
 335   {
 336     return mActionScrollUpSignal;
 337   }
 338
 339   /**
 340    * @copydoc Dali::Toolkit::AccessibilityManager::ActionScrollDownSignal
 341    */
 342   AccessibilityActionSignalType& ActionScrollDownSignal()
 343   {
 344     return mActionScrollDownSignal;
 345   }
 346
 347   /**
 348    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPageLeftSignal
 349    */
 350   AccessibilityActionSignalType& ActionPageLeftSignal()
 351   {
 352     return mActionPageLeftSignal;
 353   }
 354
 355   /**
 356    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPageRightSignal
 357    */
 358   AccessibilityActionSignalType& ActionPageRightSignal()
 359   {
 360     return mActionPageRightSignal;
 361   }
 362
 363   /**
 364    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPageUpSignal
 365    */
 366   AccessibilityActionSignalType& ActionPageUpSignal()
 367   {
 368     return mActionPageUpSignal;
 369   }
 370
 371   /**
 372    * @copydoc Dali::Toolkit::AccessibilityManager::ActionPageDownSignal
 373    */
 374   AccessibilityActionSignalType& ActionPageDownSignal()
 375   {
 376     return mActionPageDownSignal;
 377   }
 378
 379   /**
 380    * @copydoc Dali::Toolkit::AccessibilityManager::ActionMoveToFirstSignal
 381    */
 382   AccessibilityActionSignalType& ActionMoveToFirstSignal()
 383   {
 384     return mActionMoveToFirstSignal;
 385   }
 386
 387   /**
 388    * @copydoc Dali::Toolkit::AccessibilityManager::ActionMoveToLastSignal
 389    */
 390   AccessibilityActionSignalType& ActionMoveToLastSignal()
 391   {
 392     return mActionMoveToLastSignal;
 393   }
 394
 395   /**
 396    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadFromTopSignal
 397    */
 398   AccessibilityActionSignalType& ActionReadFromTopSignal()
 399   {
 400     return mActionReadFromTopSignal;
 401   }
 402
 403   /**
 404    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadFromNextSignal
 405    */
 406   AccessibilityActionSignalType& ActionReadFromNextSignal()
 407   {
 408     return mActionReadFromNextSignal;
 409   }
 410
 411   /**
 412    * @copydoc Dali::Toolkit::AccessibilityManager::ActionZoomSignal
 413    */
 414   AccessibilityActionSignalType& ActionZoomSignal()
 415   {
 416     return mActionZoomSignal;
 417   }
 418
 419   /**
 420    * @copydoc Dali::Toolkit::AccessibilityManager::ActionReadPauseResumeSignal
 421    */
 422   AccessibilityActionSignalType& ActionReadPauseResumeSignal()
 423   {
 424     return mActionReadPauseResumeSignal;
 425   }
 426
 427   /**
 428    * @copydoc Dali::Toolkit::AccessibilityManager::ActionStartStopSignal
 429    */
 430   AccessibilityActionSignalType& ActionStartStopSignal()
 431   {
 432     return mActionStartStopSignal;
 433   }
 434
 435   /**
 436    * @copydoc Dali::Toolkit::AccessibilityManager::ActionScrollSignal
 437    */
 438   AccessibilityActionScrollSignalType& ActionScrollSignal()
 439   {
 440     return mActionScrollSignal;
 441   }
 442
 443 protected:
 444
 445   /**
 446    * Destructor
 447    */
 448   virtual ~AccessibilityManager();
 449
 450 private:
 451
 452   /**
 453    * Get the additional information (e.g. focus order and description) of the given actor.
 454    * @param actorID The ID of the actor to be queried
 455    * @return The additional information of the actor
 456    */
 457   ActorAdditionalInfo GetActorAdditionalInfo(const unsigned int actorID) const;
 458
 459   /**
 460    * Synchronize the actor's additional information to reflect its latest focus order
 461    * @param actorID The ID of the actor
 462    * @param order The focus order of the actor
 463    * @return The additional information of the actor
 464    */
 465   void SynchronizeActorAdditionalInfo(const unsigned int actorID, const unsigned int order);
 466
 467   /**
 468    * Move the focus to the specified actor and send notification for the focus change.
 469    * @param actorID The ID of the actor to be queried
 470    * @return Whether the focus is successful or not
 471    */
 472   bool DoSetCurrentFocusActor(const unsigned int actorID);
 473
 474   /**
 475    * Move the focus to the next actor in the focus chain towards the specified direction.
 476    * @param focusIDIter The iterator pointing to the current focused actor
 477    * @param forward Whether the focus movement is forward or not. The focus movement will be backward if this is false.
 478    * @param wrapped Whether the focus shoule be moved wrapped around or not
 479    * @return Whether the focus is successful or not
 480    */
 481   bool DoMoveFocus(FocusIDIter focusIDIter, bool forward, bool wrapped);
 482
 483   /**
 484    * Activate the actor. If the actor is control, call OnAccessibilityActivated virtual function.
 485    * This function will emit FocusedActorActivatedSignal.
 486    * @param actor The actor to activate
 487    */
 488   void DoActivate(Actor actor);
 489
 490   /**
 491    * Set whether the actor is focusable or not. A focusable property will be registered for
 492    * the actor if not yet.
 493    * @param actor The actor to be focused
 494    * @param focusable Whether the actor is focusable or not
 495    */
 496   void SetFocusable(Actor actor, bool focusable);
 497
 498   /**
 499    * Handle the accessibility pan gesture.
 500    * @param[in]  panEvent  The pan event to be handled.
 501    * @return whether the gesture is handled successfully or not.
 502    */
 503   bool HandlePanGesture(const AccessibilityGestureEvent& panEvent) override;
 504
 505   /**
 506    * Change the accessibility status when Accessibility feature(screen-reader) turned on or off.
 507    * @return whether the status is changed or not.
 508    */
 509   bool ChangeAccessibilityStatus() override;
 510
 511   /**
 512    * Clear the accessibility focus from the current focused actor.
 513    * @return whether the focus is cleared or not.
 514    */
 515   bool ClearAccessibilityFocus() override;
 516
 517   /**
 518    * Perform the accessibility action associated with a scroll event.
 519    * @param touch The touch point (and time) of the event.
 520    * @return whether the focus is cleared or not.
 521    */
 522   bool AccessibilityActionScroll( Dali::TouchEvent& touch ) override;
 523
 524   /**
 525    * Perform the accessibility action to move focus to the previous focusable actor (by one finger flick up).
 526    * @param allowEndFeedback true if end of list feedback should be played when the focus is alread reached to the end
 527    * @return whether the accessibility action is performed or not.
 528    */
 529   bool AccessibilityActionPrevious(bool allowEndFeedback) override;
 530
 531   /**
 532    * Perform the accessibility action to move focus to the next focusable actor (by one finger flick down).
 533    * @param allowEndFeedback true if end of list feedback should be played when the focus is alread reached to the end
 534    * @return whether the accessibility action is performed or not.
 535    */
 536   bool AccessibilityActionNext(bool allowEndFeedback) override;
 537
 538   /**
 539    * Perform the accessibility action to move focus to the previous focusable actor (by one finger flick left).
 540    * @param allowEndFeedback true if end of list feedback should be played when the focus is alread reached to the end
 541    * @return whether the accessibility action is performed or not.
 542    */
 543   bool AccessibilityActionReadPrevious(bool allowEndFeedback) override;
 544
 545   /**
 546    * Perform the accessibility action to move focus to the next focusable actor (by one finger flick right).
 547    * @param allowEndFeedback true if end of list feedback should be played when the focus is alread reached to the end
 548    * @return whether the accessibility action is performed or not.
 549    */
 550   bool AccessibilityActionReadNext(bool allowEndFeedback) override;
 551
 552   /**
 553    * Perform the accessibility action to focus and read the actor (by one finger tap or move).
 554    * @param allowReadAgain true if the action read again the same object (i.e. read action)
 555    *                       false if the action just read when the focus object is changed (i.e. over action)
 556    * @return whether the accessibility action is performed or not.
 557    */
 558   bool AccessibilityActionRead(bool allowReadAgain) override;
 559
 560   /**
 561    * Perform the accessibility action to activate the current focused actor (by one finger double tap).
 562    * @return whether the accessibility action is performed or not.
 563    */
 564   bool AccessibilityActionActivate() override;
 565
 566   /**
 567    * Perform the accessibility action to change the value when the current focused actor is a slider
 568    * (by double finger down and move up and right).
 569    * @return whether the accessibility action is performed or not.
 570    */
 571   bool AccessibilityActionUp() override;
 572
 573   /**
 574    * Perform the accessibility action to change the value when the current focused actor is a slider
 575    * (by double finger down and move down and left).
 576    * @return whether the accessibility action is performed or not.
 577    */
 578   bool AccessibilityActionDown() override;
 579
 580   /**
 581    * Perform the accessibility action to navigate back (by two fingers circle draw).
 582    * @return whether the accessibility action is performed or not.
 583    */
 584   bool AccessibilityActionBack() override;
 585
 586   /**
 587    * Perform the accessibility action to scroll up the list and focus on the first item on the list
 588    * after the scrolling and read the item (by two finger swipe up).
 589    * @return whether the accessibility action is performed or not.
 590    */
 591   bool AccessibilityActionScrollUp() override;
 592
 593   /**
 594    * Perform the accessibility action to scroll down the list and focus on the first item on the list
 595    * after the scrolling and read the item (by two finger swipe down).
 596    * @return whether the accessibility action is performed or not.
 597    */
 598   bool AccessibilityActionScrollDown() override;
 599
 600   /**
 601    * Perform the accessibility action to scroll left to the previous page (by two finger swipe left).
 602    * @return whether the accessibility action is performed or not.
 603    */
 604   bool AccessibilityActionPageLeft() override;
 605
 606   /**
 607    * Perform the accessibility action to scroll right to the next page (by two finger swipe right).
 608    * @return whether the accessibility action is performed or not.
 609    */
 610   bool AccessibilityActionPageRight() override;
 611
 612   /**
 613    * Perform the accessibility action to scroll up to the previous page (by one finger swipe left and right).
 614    * @return whether the accessibility action is performed or not.
 615    */
 616   bool AccessibilityActionPageUp() override;
 617
 618   /**
 619    * Perform the accessibility action to scroll down to the next page (by one finger swipe right and left).
 620    * @return whether the accessibility action is performed or not.
 621    */
 622   bool AccessibilityActionPageDown() override;
 623
 624   /**
 625    * Perform the accessibility action to move the focus to the first item on the screen
 626    * (by one finger swipe up and down).
 627    * @return whether the accessibility action is performed or not.
 628    */
 629   bool AccessibilityActionMoveToFirst() override;
 630
 631   /**
 632    * Perform the accessibility action to move the focus to the last item on the screen
 633    * (by one finger swipe down and up).
 634    * @return whether the accessibility action is performed or not.
 635    */
 636   bool AccessibilityActionMoveToLast() override;
 637
 638   /**
 639    * Perform the accessibility action to move the focus to the first item on the top
 640    * and read from the top item continuously (by three fingers single tap).
 641    * @return whether the accessibility action is performed or not.
 642    */
 643   bool AccessibilityActionReadFromTop() override;
 644
 645   /**
 646    * Perform the accessibility action to move the focus to and read from the next item
 647    * continuously (by three fingers double tap).
 648    * @return whether the accessibility action is performed or not.
 649    */
 650   bool AccessibilityActionReadFromNext() override;
 651
 652   /**
 653    * Perform the accessibility action to move the focus to do the zooming (by one finger triple tap).
 654    * @return whether the accessibility action is performed or not.
 655    */
 656   bool AccessibilityActionZoom() override;
 657
 658   /**
 659    * Perform the accessibility action to pause/resume the current read out (by two fingers single tap).
 660    * @return whether the accessibility action is performed or not.
 661    */
 662   bool AccessibilityActionReadPauseResume() override;
 663
 664   /**
 665    * Perform the accessibility action to start/stop the current action (by two fingers double tap).
 666    * @return whether the accessibility action is performed or not.
 667    */
 668   bool AccessibilityActionStartStop() override;
 669
 670   /**
 671    * This function is connected to the TtsPlayer StateChangeSignal.
 672    * It is called when the TTS players state changes.
 673    * @param previousState The previous state of the TTS player (for comparison)
 674    * @param currentState  The current state of the TTS player
 675    */
 676   void TtsStateChanged( const Dali::TtsPlayer::State previousState, const Dali::TtsPlayer::State currentState );
 677
 678 private:
 679
 680   // Undefined
 681   AccessibilityManager(const AccessibilityManager&);
 682
 683   AccessibilityManager& operator=(const AccessibilityManager& rhs);
 684
 685 private:
 686
 687   Toolkit::AccessibilityManager::FocusChangedSignalType mFocusChangedSignal; ///< The signal to notify the focus change
 688   Toolkit::AccessibilityManager::FocusOvershotSignalType mFocusOvershotSignal; ///< The signal to notify the focus overshooted
 689   Toolkit::AccessibilityManager::FocusedActorActivatedSignalType mFocusedActorActivatedSignal; ///< The signal to notify the activation of focused actor
 690
 691   // Action signals.
 692   AccessibilityActionSignalType       mStatusChangedSignal;
 693   AccessibilityActionSignalType       mActionNextSignal;
 694   AccessibilityActionSignalType       mActionPreviousSignal;
 695   AccessibilityActionSignalType       mActionActivateSignal;
 696   AccessibilityActionSignalType       mActionOverSignal;
 697   AccessibilityActionSignalType       mActionReadSignal;
 698   AccessibilityActionSignalType       mActionReadNextSignal;
 699   AccessibilityActionSignalType       mActionReadPreviousSignal;
 700   AccessibilityActionSignalType       mActionUpSignal;
 701   AccessibilityActionSignalType       mActionDownSignal;
 702   AccessibilityActionSignalType       mActionClearFocusSignal;
 703   AccessibilityActionSignalType       mActionBackSignal;
 704   AccessibilityActionSignalType       mActionScrollUpSignal;
 705   AccessibilityActionSignalType       mActionScrollDownSignal;
 706   AccessibilityActionSignalType       mActionPageLeftSignal;
 707   AccessibilityActionSignalType       mActionPageRightSignal;
 708   AccessibilityActionSignalType       mActionPageUpSignal;
 709   AccessibilityActionSignalType       mActionPageDownSignal;
 710   AccessibilityActionSignalType       mActionMoveToFirstSignal;
 711   AccessibilityActionSignalType       mActionMoveToLastSignal;
 712   AccessibilityActionSignalType       mActionReadFromTopSignal;
 713   AccessibilityActionSignalType       mActionReadFromNextSignal;
 714   AccessibilityActionSignalType       mActionZoomSignal;
 715   AccessibilityActionSignalType       mActionReadPauseResumeSignal;
 716   AccessibilityActionSignalType       mActionStartStopSignal;
 717   AccessibilityActionScrollSignalType mActionScrollSignal;
 718
 719   FocusIDContainer mFocusIDContainer;       ///< The container to look up actor ID by focus order
 720   IDAdditionalInfoContainer mIDAdditionalInfoContainer; ///< The container to look up additional information by actor ID
 721   FocusIDPair mCurrentFocusActor;           ///< The focus order and actor ID of current focused actor
 722   Actor mCurrentGesturedActor;              ///< The actor that will handle the gesture
 723   Actor mFocusIndicatorActor;               ///< The focus indicator actor shared by all the focusable actors for highlight
 724   Vector2 mPreviousPosition;                ///< The previous pan position; useful for calculating velocity for GestureState::FINISHED events
 725   unsigned int mRecursiveFocusMoveCounter;  ///< The counter to count the number of recursive focus movement attempted before the focus movement is successful.
 726   std::string mFocusSoundFilePath;          ///< The path of the focus sound file
 727   std::string mFocusChainEndSoundFilePath;  ///< The path of the focus chain end sound file
 728
 729   bool mIsWrapped:1;                        ///< Whether the focus movement is wrapped around or not
 730   bool mIsFocusWithinGroup:1;               ///< Whether the focus movement is limited to the current focus group or not
 731   bool mIsEndcapFeedbackEnabled:1;          ///< Whether the endcap feedback need to be played when the focus leaves the end or vice versa
 732   bool mIsEndcapFeedbackPlayed:1;           ///< Whether the endcap feedback was played or not
 733   bool mIsAccessibilityTtsEnabled:1;        ///< Whether accessibility feature(screen-reader) turned on/off
 734   bool mTtsCreated:1;                       ///< Whether the TTS Player has been accessed
 735   bool mIsFocusIndicatorEnabled:1;          ///< Whether indicator should be shown / hidden. It could be enabled when TTS enabled or 'Tab' key operated.
 736   bool mContinuousPlayMode:1;               ///< Keeps track of whether or not we are in continuous play mode
 737   bool mIsFocusSoundFilePathSet:1;          ///< Whether the path of the focus sound file has been set
 738   bool mIsFocusChainEndSoundFilePathSet:1;  ///< Whether the path of the focus chain end sound file has been set
 739
 740 };
 741
 742 } // namespace Internal
 743
 744 inline Internal::AccessibilityManager& GetImpl(Dali::Toolkit::AccessibilityManager& obj)
 745 {
 746   DALI_ASSERT_ALWAYS(obj);
 747
 748   Dali::BaseObject& handle = obj.GetBaseObject();
 749
 750   return static_cast<Internal::AccessibilityManager&>(handle);
 751 }
 752
 753 inline const Internal::AccessibilityManager& GetImpl(const Dali::Toolkit::AccessibilityManager& obj)
 754 {
 755   DALI_ASSERT_ALWAYS(obj);
 756
 757   const Dali::BaseObject& handle = obj.GetBaseObject();
 758
 759   return static_cast<const Internal::AccessibilityManager&>(handle);
 760 }
 761
 762 } // namespace Toolkit
 763
 764 } // namespace Dali
 765
 766 #endif // DALI_TOOLKIT_INTERNAL_ACCESSIBILITY_MANAGER_H