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