dali-toolkit/public-api/accessibility-manager/accessibility-manager.h

   1 #ifndef __DALI_TOOLKIT_ACCESSIBILITY_MANAGER_H__
   2 #define __DALI_TOOLKIT_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 <dali/public-api/actors/actor.h>
  23 #include <dali/public-api/actors/image-actor.h>
  24
  25 namespace Dali
  26 {
  27
  28 namespace Toolkit
  29 {
  30
  31 namespace Internal DALI_INTERNAL
  32 {
  33 class AccessibilityManager;
  34 }
  35
  36 /**
  37  * @brief Manages registration of actors in a accessibility focus chain and changing the
  38  * focused actor within that chain.
  39  *
  40  * This class provides the functionality of registering the focus order and description
  41  * of actors and maintaining the focus chain.
  42  *
  43  * It provides functionality of setting the
  44  * focus and moving the focus forward and backward. It also draws a highlight for the
  45  * focused actor and emits a signal when the focus is changed.
  46  *
  47  * Signals
  48  * | %Signal Name            | Method                             |
  49  * |-------------------------|------------------------------------|
  50  * | focus-changed           | @ref FocusChangedSignal()          |
  51  * | focus-overshot          | @ref FocusOvershotSignal()         |
  52  * | focused-actor-activated | @ref FocusedActorActivatedSignal() |
  53  */
  54 class DALI_IMPORT_API AccessibilityManager : public BaseHandle
  55 {
  56 public:
  57
  58   // Typedefs
  59
  60   /**
  61    * @brief Accessibility Action Signal.
  62    *
  63    * The connected signal callback should return true if handled.
  64    */
  65   typedef Signal< bool ( AccessibilityManager& ) > AccessibilityActionSignalType; ///< Generic signal type
  66   typedef Signal< bool ( AccessibilityManager&, const Dali::TouchEvent& )> AccessibilityActionScrollSignalType; ///< Scroll signal type
  67
  68   /**
  69    * @brief Accessibility needs four information which will be read by screen-reader.
  70    *
  71    * Reading order : Label -> Trait -> Optional (Value and Hint)
  72    */
  73   enum AccessibilityAttribute
  74   {
  75     ACCESSIBILITY_LABEL = 0, ///< Simple text which contained in ui-control
  76     ACCESSIBILITY_TRAIT,     ///< Description of ui-control trait
  77     ACCESSIBILITY_VALUE,     ///< Current value of ui-control (Optional)
  78     ACCESSIBILITY_HINT,      ///< Hint for action (Optional)
  79     ACCESSIBILITY_ATTRIBUTE_NUM ///< Number of attributes
  80   };
  81
  82    /**
  83     * @brief Overshoot direction.
  84     */
  85   enum FocusOvershotDirection
  86   {
  87     OVERSHOT_PREVIOUS = -1, ///< Try to move previous of the first actor
  88     OVERSHOT_NEXT = 1,      ///< Try to move next of the last actor
  89   };
  90
  91  public:
  92
  93   /// @brief Focus changed signal
  94   typedef Signal< void ( Actor, Actor ) > FocusChangedSignalType;
  95
  96   /// @brief Focus overshooted signal
  97   typedef Signal< void ( Actor, FocusOvershotDirection ) > FocusOvershotSignalType;
  98
  99   /// @brief Focused actor activated signal
 100   typedef Signal< void ( Actor ) > FocusedActorActivatedSignalType;
 101
 102   /**
 103    * @brief Create a AccessibilityManager handle; this can be initialised with AccessibilityManager::New().
 104    *
 105    * Calling member functions with an uninitialised handle is not allowed.
 106    */
 107   AccessibilityManager();
 108
 109   /**
 110    * @brief Destructor
 111    *
 112    * This is non-virtual since derived Handle types must not contain data or virtual methods.
 113    */
 114   ~AccessibilityManager();
 115
 116   /**
 117    * @brief Get the singleton of AccessibilityManager object.
 118    *
 119    * @return A handle to the AccessibilityManager control.
 120    */
 121   static AccessibilityManager Get();
 122
 123   /**
 124    * @brief Set the information of the specified actor's accessibility attribute.
 125    *
 126    * @pre The AccessibilityManager has been initialized.
 127    * @pre The Actor has been initialized.
 128    * @param actor The actor the text to be set with
 129    * @param type The attribute type the text to be set with
 130    * @param text The text for the actor's accessibility information
 131    */
 132   void SetAccessibilityAttribute(Actor actor, AccessibilityAttribute type, const std::string& text);
 133
 134   /**
 135    * @brief Get the text of the specified actor's accessibility attribute.
 136    *
 137    * @pre The AccessibilityManager has been initialized.
 138    * @pre The Actor has been initialized.
 139    * @param actor The actor to be queried
 140    * @param type The attribute type to be queried
 141    * @return The text of the actor's accessibility information
 142    */
 143   std::string GetAccessibilityAttribute(Actor actor, AccessibilityAttribute type) const;
 144
 145   /**
 146    * @brief Set the focus order of the actor.
 147    *
 148    * The focus order of each actor in the focus chain is unique. If
 149    * there is another actor assigned with the same focus order
 150    * already, the new actor will be inserted to the focus chain with
 151    * that focus order, and the focus order of the original actor and
 152    * all the actors followed in the focus chain will be increased
 153    * accordingly. If the focus order assigned to the actor is 0, it
 154    * means that actor's focus order is undefined (e.g. the actor has a
 155    * description but with no focus order being set yet) and therefore
 156    * that actor is not focusable.
 157    *
 158    * @pre The AccessibilityManager has been initialized.
 159    * @pre The Actor has been initialized.
 160    * @param actor The actor the focus order to be set with
 161    * @param order The focus order of the actor
 162    */
 163   void SetFocusOrder(Actor actor, const unsigned int order);
 164
 165   /**
 166    * @brief Get the focus order of the actor.
 167    *
 168    * When the focus order is 0, it means the focus order of the actor
 169    * is undefined.
 170    *
 171    * @pre The AccessibilityManager has been initialized.
 172    * @pre The Actor has been initialized.
 173    * @param actor The actor to be queried
 174    * @return The focus order of the actor
 175    */
 176   unsigned int GetFocusOrder(Actor actor) const;
 177
 178   /**
 179    * @brief Generates a new focus order number which can be used to
 180    * assign to actors which need to be appended to the end of the
 181    * current focus order chain.
 182    *
 183    * The new number will be an increment over the very last focus
 184    * order number in the focus chain. If the focus chain is empty then
 185    * the function returns 1, else the number returned will be FOLast +
 186    * 1 where FOLast is the focus order of the very last control in the
 187    * focus chain.
 188    *
 189    * @pre The AccessibilityManager has been initialized.
 190    * @return The focus order of the actor
 191    */
 192   unsigned int GenerateNewFocusOrder() const;
 193
 194   /**
 195    * @brief Get the actor that has the specified focus order.
 196    *
 197    * It will return an empty handle if the actor is not in the stage
 198    * or has a focus order of 0.
 199    *
 200    * @pre The AccessibilityManager has been initialized.
 201    * @param order The focus order of the actor
 202    *
 203    * @return The actor that has the specified focus order or an empty
 204    * handle if no actor in the stage has the specified focus order.
 205    */
 206   Actor GetActorByFocusOrder(const unsigned int order);
 207
 208   /**
 209    * @brief Move the focus to the specified actor.
 210    *
 211    * Only one actor can be focused at the same time.  The actor must
 212    * have a defined focus order and must be focusable, visible and in
 213    * the stage.
 214    *
 215    * @pre The AccessibilityManager has been initialized.
 216    * @pre The Actor has been initialized.
 217    * @param actor The actor to be focused
 218    * @return Whether the focus is successful or not
 219    */
 220   bool SetCurrentFocusActor(Actor actor);
 221
 222   /**
 223    * @brief Get the current focused actor.
 224    *
 225    * @pre The AccessibilityManager has been initialized.
 226    * @return A handle to the current focused actor or an empty handle if no actor is focused.
 227    */
 228   Actor GetCurrentFocusActor();
 229
 230   /**
 231    * @brief Get the focus group of current focused actor.
 232    *
 233    * @pre The AccessibilityManager has been initialized.
 234    *
 235    * @return A handle to the immediate parent of the current focused
 236    * actor which is also a focus group, or an empty handle if no actor
 237    * is focused.
 238    */
 239   Actor GetCurrentFocusGroup();
 240
 241   /**
 242    * @brief Get the focus order of currently focused actor.
 243    * @pre The AccessibilityManager has been initialized.
 244    *
 245    * @return The focus order of the currently focused actor or 0 if no
 246    * actor is in focus.
 247    */
 248   unsigned int GetCurrentFocusOrder();
 249
 250   /**
 251    * @brief Move the focus to the next focusable actor in the focus
 252    * chain (according to the focus traversal order).
 253    *
 254    * When the focus movement is wrapped around, the focus will be moved
 255    * to the first focusable actor when it reaches the end of the focus chain.
 256    *
 257    * @pre The AccessibilityManager has been initialized.
 258    * @return true if the moving was successful
 259    */
 260   bool MoveFocusForward();
 261
 262   /**
 263    * @brief Move the focus to the previous focusable actor in the
 264    * focus chain (according to the focus traversal order).
 265    *
 266    * When the focus movement is wrapped around, the focus will be
 267    * moved to the last focusable actor when it reaches the beginning
 268    * of the focus chain.
 269    *
 270    * @pre The AccessibilityManager has been initialized.
 271    * @return true if the moving was successful
 272    */
 273   bool MoveFocusBackward();
 274
 275   /**
 276    * @brief Clear the focus from the current focused actor if any, so
 277    * that no actor is focused in the focus chain.
 278    *
 279    * It will emit focus changed signal without current focused actor
 280    * @pre The AccessibilityManager has been initialized.
 281    */
 282   void ClearFocus();
 283
 284   /**
 285    * @brief Clear the every registered focusable actor from focus-manager.
 286    * @pre The AccessibilityManager has been initialized.
 287    */
 288   void Reset();
 289
 290   /**
 291    * @brief Set whether an actor is a focus group that can limit the
 292    * scope of focus movement to its child actors in the focus chain.
 293    *
 294    * @pre The AccessibilityManager has been initialized.
 295    * @pre The Actor has been initialized.
 296    * @param actor The actor to be set as a focus group.
 297    * @param isFocusGroup Whether to set the actor to be a focus group or not.
 298    */
 299   void SetFocusGroup(Actor actor, bool isFocusGroup);
 300
 301   /**
 302    * @brief Check whether the actor is set as a focus group or not.
 303    *
 304    * @pre The AccessibilityManager has been initialized.
 305    * @pre The Actor has been initialized.
 306    * @param actor The actor to be checked.
 307    * @return Whether the actor is set as a focus group.
 308    */
 309   bool IsFocusGroup(Actor actor) const;
 310
 311   /**
 312    * @brief Set whether the group mode is enabled or not.
 313    *
 314    * When the group mode is enabled, the focus movement will be limited to the child actors
 315    * of the current focus group including the current focus group itself. The current focus
 316    * group is the closest ancestor of the current focused actor that set as a focus group.
 317    * @pre The AccessibilityManager has been initialized.
 318    * @param enabled Whether the group mode is enabled or not
 319    */
 320   void SetGroupMode(bool enabled);
 321
 322   /**
 323    * @brief Get whether the group mode is enabled or not.
 324    *
 325    * @pre The AccessibilityManager has been initialized.
 326    * @return Whether the group mode is enabled or not.
 327    */
 328   bool GetGroupMode() const;
 329
 330   /**
 331    * @brief Set whether focus will be moved to the beginning of the
 332    * focus chain when it reaches the end or vice versa.
 333    *
 334    * When both the wrap mode and the group mode are enabled, focus will be
 335    * wrapped within the current focus group. Focus will not be wrapped in default.
 336    * @pre The AccessibilityManager has been initialized.
 337    * @param wrapped Whether the focus movement is wrapped around or not
 338    */
 339   void SetWrapMode(bool wrapped);
 340
 341   /**
 342    * @brief Get whether the wrap mode is enabled or not.
 343    *
 344    * @pre The AccessibilityManager has been initialized.
 345    * @return Whether the wrap mode is enabled or not.
 346    */
 347   bool GetWrapMode() const;
 348
 349   /**
 350    * @brief Set the focus indicator actor.
 351    *
 352    * This will replace the default focus indicator actor in
 353    * AccessibilityManager and will be added to the focused actor as a
 354    * highlight.
 355    *
 356    * @pre The AccessibilityManager has been initialized.
 357    * @pre The indicator actor has been initialized.
 358    * @param indicator The indicator actor to be added
 359    */
 360   void SetFocusIndicatorActor(Actor indicator);
 361
 362   /**
 363    * @brief Get the focus indicator actor.
 364    *
 365    * @pre The AccessibilityManager has been initialized.
 366    * @return A handle to the focus indicator actor
 367    */
 368   Actor GetFocusIndicatorActor();
 369
 370   /**
 371    * @brief Returns the closest ancestor of the given actor that is a focus group.
 372    *
 373    * @param actor The actor to be checked for its focus group
 374    * @return The focus group the given actor belongs to or an empty handle if the given actor doesn't belong to any focus group
 375    */
 376   Actor GetFocusGroup(Actor actor);
 377
 378   /**
 379    * @brief Returns the current position of the read action.
 380    * @return The current event position.
 381    */
 382   Vector2 GetReadPosition() const;
 383
 384  public: // Signals
 385
 386   /**
 387    * @brief This signal is emitted when the current focused actor is changed.
 388    *
 389    * A callback of the following type may be connected:
 390    * @code
 391    *   void YourCallbackName(Actor originalFocusedActor, Actor currentFocusedActor);
 392    * @endcode
 393    * @pre The Object has been initialized.
 394    * @return The signal to connect to.
 395    */
 396   FocusChangedSignalType& FocusChangedSignal();
 397
 398   /**
 399    * @brief This signal is emitted when there is no way to move focus further.
 400    *
 401    * A callback of the following type may be connected:
 402    * @code
 403    *   void YourCallbackName(Actor currentFocusedActor, FocusOvershotDirection direction);
 404    * @endcode
 405    * @pre The Object has been initialized.
 406    * @return The signal to connect to.
 407    */
 408   FocusOvershotSignalType& FocusOvershotSignal();
 409
 410   /**
 411    * @brief This signal is emitted when the current focused actor is activated.
 412    *
 413    * A callback of the following type may be connected:
 414    * @code
 415    *   void YourCallbackName(Actor activatedActor);
 416    * @endcode
 417    * @pre The Object has been initialized.
 418    * @return The signal to connect to.
 419    */
 420   FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
 421
 422  public: // Accessibility action signals.
 423
 424   /**
 425    * @brief This is emitted when accessibility(screen-reader) feature turned on or off.
 426    *
 427    * A callback of the following type may be connected:
 428    * @code
 429    *   bool YourCallback( AccessibilityManager& manager );
 430    * @endcode
 431    * @return The signal to connect to.
 432    */
 433   AccessibilityActionSignalType& StatusChangedSignal();
 434
 435   /**
 436    * @brief This is emitted when accessibility action is received to move focus to the next
 437    * focusable actor (by one finger flick down).
 438    *
 439    * A callback of the following type may be connected:
 440    * @code
 441    *   bool YourCallback( AccessibilityManager& manager );
 442    * @endcode
 443    * @return The signal to connect to.
 444    */
 445   AccessibilityActionSignalType& ActionNextSignal();
 446
 447   /**
 448    * @brief This is emitted when accessibility action is received to move focus to the previous
 449    * focusable actor (by one finger flick up).
 450    *
 451    * A callback of the following type may be connected:
 452    * @code
 453    *   bool YourCallback( AccessibilityManager& manager );
 454    * @endcode
 455    * @return The signal to connect to.
 456    */
 457   AccessibilityActionSignalType& ActionPreviousSignal();
 458
 459   /**
 460    * @brief This is emitted when accessibility action is received to activate the current focused
 461    * actor (by one finger double tap).
 462    *
 463    * A callback of the following type may be connected:
 464    * @code
 465    *   bool YourCallback( AccessibilityManager& manager );
 466    * @endcode
 467    * @return The signal to connect to.
 468    */
 469   AccessibilityActionSignalType& ActionActivateSignal();
 470
 471   /**
 472    * @brief This is emitted when accessibility action is received to focus and read the actor
 473    * (by one finger tap).
 474    *
 475    * A callback of the following type may be connected:
 476    * @code
 477    *   bool YourCallback( AccessibilityManager& manager );
 478    * @endcode
 479    * @return The signal to connect to.
 480    */
 481   AccessibilityActionSignalType& ActionReadSignal();
 482
 483   /**
 484    * @brief This is emitted when accessibility action is received to focus and read the actor
 485    * (by one finger move).
 486    *
 487    * A callback of the following type may be connected:
 488    * @code
 489    *   bool YourCallback( AccessibilityManager& manager );
 490    * @endcode
 491    * @return The signal to connect to.
 492    */
 493   AccessibilityActionSignalType& ActionOverSignal();
 494
 495   /**
 496    * @brief This is emitted when accessibility action is received to move focus to the next
 497    * focusable actor (by one finger flick right).
 498    *
 499    * A callback of the following type may be connected:
 500    * @code
 501    *   bool YourCallback( AccessibilityManager& manager );
 502    * @endcode
 503    * @return The signal to connect to.
 504    */
 505   AccessibilityActionSignalType& ActionReadNextSignal();
 506
 507   /**
 508    * @brief This is emitted when accessibility action is received to move focus to the previous
 509    * focusable actor (by one finger flick left).
 510    *
 511    * A callback of the following type may be connected:
 512    * @code
 513    *   bool YourCallback( AccessibilityManager& manager );
 514    * @endcode
 515    * @return The signal to connect to.
 516    */
 517   AccessibilityActionSignalType& ActionReadPreviousSignal();
 518
 519   /**
 520    * @brief This is emitted when accessibility action is received to change the value when the
 521    * current focused actor is a slider (by double finger down and move up and right).
 522    *
 523    * A callback of the following type may be connected:
 524    * @code
 525    *   bool YourCallback( AccessibilityManager& manager );
 526    * @endcode
 527    * @return The signal to connect to.
 528    */
 529   AccessibilityActionSignalType& ActionUpSignal();
 530
 531   /**
 532    * @brief This is emitted when accessibility action is received to change the value when the
 533    * current focused actor is a slider (by double finger down and move down and left).
 534    *
 535    * A callback of the following type may be connected:
 536    * @code
 537    *   bool YourCallback( AccessibilityManager& manager );
 538    * @endcode
 539    * @return The signal to connect to.
 540    */
 541   AccessibilityActionSignalType& ActionDownSignal();
 542
 543   /**
 544    * @brief This is emitted when accessibility action is received to clear the focus from the
 545    * current focused actor if any, so that no actor is focused in the focus chain.
 546    *
 547    * A callback of the following type may be connected:
 548    * @code
 549    *   bool YourCallback( AccessibilityManager& manager );
 550    * @endcode
 551    * @return The signal to connect to.
 552    */
 553   AccessibilityActionSignalType& ActionClearFocusSignal();
 554
 555   /**
 556    * @brief This is emitted when accessibility action is received to navigate back (by two
 557    * fingers circle draw).
 558    *
 559    * A callback of the following type may be connected:
 560    * @code
 561    *   bool YourCallback( AccessibilityManager& manager );
 562    * @endcode
 563    * @return The signal to connect to.
 564    */
 565   AccessibilityActionSignalType& ActionBackSignal();
 566
 567   /**
 568    * @brief This is emitted when accessibility action is received to scroll up the list
 569    * (by two finger swipe up).
 570    *
 571    * A callback of the following type may be connected:
 572    * @code
 573    *   bool YourCallback( AccessibilityManager& manager );
 574    * @endcode
 575    * @return The signal to connect to.
 576    */
 577   AccessibilityActionSignalType& ActionScrollUpSignal();
 578
 579   /**
 580    * @brief This is emitted when accessibility action is received to scroll down the list
 581    * (by two finger swipe down).
 582    *
 583    * A callback of the following type may be connected:
 584    * @code
 585    *   bool YourCallback( AccessibilityManager& manager );
 586    * @endcode
 587    * @return The signal to connect to.
 588    */
 589   AccessibilityActionSignalType& ActionScrollDownSignal();
 590
 591   /**
 592    * @brief This is emitted when accessibility action is received to scroll left to the
 593    * previous page (by two finger swipe left)
 594    *
 595    * A callback of the following type may be connected:
 596    * @code
 597    *   bool YourCallback( AccessibilityManager& manager );
 598    * @endcode
 599    * @return The signal to connect to.
 600    */
 601   AccessibilityActionSignalType& ActionPageLeftSignal();
 602
 603   /**
 604    * @brief This is emitted when accessibility action is received to scroll right to the
 605    * next page (by two finger swipe right)
 606    *
 607    * A callback of the following type may be connected:
 608    * @code
 609    *   bool YourCallback( AccessibilityManager& manager );
 610    * @endcode
 611    * @return The signal to connect to.
 612    */
 613   AccessibilityActionSignalType& ActionPageRightSignal();
 614
 615   /**
 616    * @brief This is emitted when accessibility action is received to scroll up to the
 617    * previous page (by one finger swipe left and right)
 618    *
 619    * A callback of the following type may be connected:
 620    * @code
 621    *   bool YourCallback( AccessibilityManager& manager );
 622    * @endcode
 623    * @return The signal to connect to.
 624    */
 625   AccessibilityActionSignalType& ActionPageUpSignal();
 626
 627   /**
 628    * @brief This is emitted when accessibility action is received to scroll down to the
 629    * next page (by one finger swipe right and left)
 630    *
 631    * A callback of the following type may be connected:
 632    * @code
 633    *   bool YourCallback( AccessibilityManager& manager );
 634    * @endcode
 635    * @return The signal to connect to.
 636    */
 637   AccessibilityActionSignalType& ActionPageDownSignal();
 638
 639   /**
 640    * @brief This is emitted when accessibility action is received to move the focus to
 641    * the first item on the screen (by one finger swipe up and down)
 642    *
 643    * A callback of the following type may be connected:
 644    * @code
 645    *   bool YourCallback( AccessibilityManager& manager );
 646    * @endcode
 647    * @return The signal to connect to.
 648    */
 649   AccessibilityActionSignalType& ActionMoveToFirstSignal();
 650
 651   /**
 652    * @brief This is emitted when accessibility action is received to move the focus to
 653    * the last item on the screen (by one finger swipe down and up)
 654    *
 655    * A callback of the following type may be connected:
 656    * @code
 657    *   bool YourCallback( AccessibilityManager& manager );
 658    * @endcode
 659    * @return The signal to connect to.
 660    */
 661   AccessibilityActionSignalType& ActionMoveToLastSignal();
 662
 663   /**
 664    * @brief This is emitted when accessibility action is received to focus and read from the
 665    * first item on the top continously (by three fingers single tap)
 666    *
 667    * A callback of the following type may be connected:
 668    * @code
 669    *   bool YourCallback( AccessibilityManager& manager );
 670    * @endcode
 671    * @return The signal to connect to.
 672    */
 673   AccessibilityActionSignalType& ActionReadFromTopSignal();
 674
 675   /**
 676    * @brief This is emitted when accessibility action is received to move the focus to and
 677    * read from the next item continously (by three fingers double tap)
 678    *
 679    * A callback of the following type may be connected:
 680    * @code
 681    *   bool YourCallback( AccessibilityManager& manager );
 682    * @endcode
 683    * @return The signal to connect to.
 684    */
 685   AccessibilityActionSignalType& ActionReadFromNextSignal();
 686
 687   /**
 688    * @brief This is emitted when accessibility action is received to zoom (by one finger
 689    * triple tap)
 690    *
 691    * A callback of the following type may be connected:
 692    * @code
 693    *   bool YourCallback( AccessibilityManager& manager );
 694    * @endcode
 695    * @return The signal to connect to.
 696    */
 697   AccessibilityActionSignalType& ActionZoomSignal();
 698
 699   /**
 700    * @brief This is emitted when accessibility action is received to read the information
 701    * in the indicator (by two fingers triple tap).
 702    *
 703    * A callback of the following type may be connected:
 704    * @code
 705    *   bool YourCallback( AccessibilityManager& manager );
 706    * @endcode
 707    * @return The signal to connect to.
 708    */
 709   AccessibilityActionSignalType& ActionReadIndicatorInformationSignal();
 710
 711   /**
 712    * @brief This is emitted when accessibility action is received to pause/resume the
 713    * current speech (by two fingers single tap).
 714    *
 715    * A callback of the following type may be connected:
 716    * @code
 717    *   bool YourCallback( AccessibilityManager& manager );
 718    * @endcode
 719    * @return The signal to connect to.
 720    */
 721   AccessibilityActionSignalType& ActionReadPauseResumeSignal();
 722
 723   /**
 724    * @brief This is emitted when accessibility action is received to start/stop the
 725    * current action (by two fingers double tap).
 726    *
 727    * A callback of the following type may be connected:
 728    * @code
 729    *   bool YourCallback( AccessibilityManager& manager );
 730    * @endcode
 731    * @return The signal to connect to.
 732    */
 733   AccessibilityActionSignalType& ActionStartStopSignal();
 734
 735   /**
 736    * @brief This is emitted when accessibility action is received to handle scroll event (by two
 737    * fingers drag).
 738    *
 739    * A callback of the following type may be connected:
 740    * @code
 741    *   bool YourCallback( AccessibilityManager& manager, const TouchEvent& event );
 742    * @endcode
 743    * @return The signal to connect to.
 744    */
 745   AccessibilityActionScrollSignalType& ActionScrollSignal();
 746
 747 public:
 748
 749   explicit DALI_INTERNAL AccessibilityManager( Internal::AccessibilityManager *impl );
 750
 751 }; // class AccessibilityManager
 752
 753 } // namespace Toolkit
 754
 755 } // namespace Dali
 756
 757 #endif // __DALI_TOOLKIT_ACCESSIBILITY_MANAGER_H__