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