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