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  public: // Signals
 379
 380   /**
 381    * @brief This signal is emitted when the current focused actor is changed.
 382    *
 383    * A callback of the following type may be connected:
 384    * @code
 385    *   void YourCallbackName(Actor originalFocusedActor, Actor currentFocusedActor);
 386    * @endcode
 387    * @pre The Object has been initialized.
 388    * @return The signal to connect to.
 389    */
 390   FocusChangedSignalType& FocusChangedSignal();
 391
 392   /**
 393    * @brief This signal is emitted when there is no way to move focus further.
 394    *
 395    * A callback of the following type may be connected:
 396    * @code
 397    *   void YourCallbackName(Actor currentFocusedActor, FocusOvershotDirection direction);
 398    * @endcode
 399    * @pre The Object has been initialized.
 400    * @return The signal to connect to.
 401    */
 402   FocusOvershotSignalType& FocusOvershotSignal();
 403
 404   /**
 405    * @brief This signal is emitted when the current focused actor is activated.
 406    *
 407    * A callback of the following type may be connected:
 408    * @code
 409    *   void YourCallbackName(Actor activatedActor);
 410    * @endcode
 411    * @pre The Object has been initialized.
 412    * @return The signal to connect to.
 413    */
 414   FocusedActorActivatedSignalType& FocusedActorActivatedSignal();
 415
 416  public: // Accessibility action signals.
 417
 418   /**
 419    * @brief This is emitted when accessibility(screen-reader) feature turned on or off.
 420    *
 421    * A callback of the following type may be connected:
 422    * @code
 423    *   bool YourCallback( AccessibilityManager& manager );
 424    * @endcode
 425    * @return The signal to connect to.
 426    */
 427   AccessibilityActionSignalType& StatusChangedSignal();
 428
 429   /**
 430    * @brief This is emitted when accessibility action is received to move focus to the next
 431    * focusable actor (by one finger flick down).
 432    *
 433    * A callback of the following type may be connected:
 434    * @code
 435    *   bool YourCallback( AccessibilityManager& manager );
 436    * @endcode
 437    * @return The signal to connect to.
 438    */
 439   AccessibilityActionSignalType& ActionNextSignal();
 440
 441   /**
 442    * @brief This is emitted when accessibility action is received to move focus to the previous
 443    * focusable actor (by one finger flick up).
 444    *
 445    * A callback of the following type may be connected:
 446    * @code
 447    *   bool YourCallback( AccessibilityManager& manager );
 448    * @endcode
 449    * @return The signal to connect to.
 450    */
 451   AccessibilityActionSignalType& ActionPreviousSignal();
 452
 453   /**
 454    * @brief This is emitted when accessibility action is received to activate the current focused
 455    * actor (by one finger double tap).
 456    *
 457    * A callback of the following type may be connected:
 458    * @code
 459    *   bool YourCallback( AccessibilityManager& manager );
 460    * @endcode
 461    * @return The signal to connect to.
 462    */
 463   AccessibilityActionSignalType& ActionActivateSignal();
 464
 465   /**
 466    * @brief This is emitted when accessibility action is received to focus and read the actor
 467    * (by one finger tap).
 468    *
 469    * A callback of the following type may be connected:
 470    * @code
 471    *   bool YourCallback( AccessibilityManager& manager );
 472    * @endcode
 473    * @return The signal to connect to.
 474    */
 475   AccessibilityActionSignalType& ActionReadSignal();
 476
 477   /**
 478    * @brief This is emitted when accessibility action is received to focus and read the actor
 479    * (by one finger move).
 480    *
 481    * A callback of the following type may be connected:
 482    * @code
 483    *   bool YourCallback( AccessibilityManager& manager );
 484    * @endcode
 485    * @return The signal to connect to.
 486    */
 487   AccessibilityActionSignalType& ActionOverSignal();
 488
 489   /**
 490    * @brief This is emitted when accessibility action is received to move focus to the next
 491    * focusable actor (by one finger flick right).
 492    *
 493    * A callback of the following type may be connected:
 494    * @code
 495    *   bool YourCallback( AccessibilityManager& manager );
 496    * @endcode
 497    * @return The signal to connect to.
 498    */
 499   AccessibilityActionSignalType& ActionReadNextSignal();
 500
 501   /**
 502    * @brief This is emitted when accessibility action is received to move focus to the previous
 503    * focusable actor (by one finger flick left).
 504    *
 505    * A callback of the following type may be connected:
 506    * @code
 507    *   bool YourCallback( AccessibilityManager& manager );
 508    * @endcode
 509    * @return The signal to connect to.
 510    */
 511   AccessibilityActionSignalType& ActionReadPreviousSignal();
 512
 513   /**
 514    * @brief This is emitted when accessibility action is received to change the value when the
 515    * current focused actor is a slider (by double finger down and move up and right).
 516    *
 517    * A callback of the following type may be connected:
 518    * @code
 519    *   bool YourCallback( AccessibilityManager& manager );
 520    * @endcode
 521    * @return The signal to connect to.
 522    */
 523   AccessibilityActionSignalType& ActionUpSignal();
 524
 525   /**
 526    * @brief This is emitted when accessibility action is received to change the value when the
 527    * current focused actor is a slider (by double finger down and move down and left).
 528    *
 529    * A callback of the following type may be connected:
 530    * @code
 531    *   bool YourCallback( AccessibilityManager& manager );
 532    * @endcode
 533    * @return The signal to connect to.
 534    */
 535   AccessibilityActionSignalType& ActionDownSignal();
 536
 537   /**
 538    * @brief This is emitted when accessibility action is received to clear the focus from the
 539    * current focused actor if any, so that no actor is focused in the focus chain.
 540    *
 541    * A callback of the following type may be connected:
 542    * @code
 543    *   bool YourCallback( AccessibilityManager& manager );
 544    * @endcode
 545    * @return The signal to connect to.
 546    */
 547   AccessibilityActionSignalType& ActionClearFocusSignal();
 548
 549   /**
 550    * @brief This is emitted when accessibility action is received to navigate back (by two
 551    * fingers circle draw).
 552    *
 553    * A callback of the following type may be connected:
 554    * @code
 555    *   bool YourCallback( AccessibilityManager& manager );
 556    * @endcode
 557    * @return The signal to connect to.
 558    */
 559   AccessibilityActionSignalType& ActionBackSignal();
 560
 561   /**
 562    * @brief This is emitted when accessibility action is received to scroll up the list
 563    * (by two finger swipe up).
 564    *
 565    * A callback of the following type may be connected:
 566    * @code
 567    *   bool YourCallback( AccessibilityManager& manager );
 568    * @endcode
 569    * @return The signal to connect to.
 570    */
 571   AccessibilityActionSignalType& ActionScrollUpSignal();
 572
 573   /**
 574    * @brief This is emitted when accessibility action is received to scroll down the list
 575    * (by two finger swipe down).
 576    *
 577    * A callback of the following type may be connected:
 578    * @code
 579    *   bool YourCallback( AccessibilityManager& manager );
 580    * @endcode
 581    * @return The signal to connect to.
 582    */
 583   AccessibilityActionSignalType& ActionScrollDownSignal();
 584
 585   /**
 586    * @brief This is emitted when accessibility action is received to scroll left to the
 587    * previous page (by two finger swipe left)
 588    *
 589    * A callback of the following type may be connected:
 590    * @code
 591    *   bool YourCallback( AccessibilityManager& manager );
 592    * @endcode
 593    * @return The signal to connect to.
 594    */
 595   AccessibilityActionSignalType& ActionPageLeftSignal();
 596
 597   /**
 598    * @brief This is emitted when accessibility action is received to scroll right to the
 599    * next page (by two finger swipe right)
 600    *
 601    * A callback of the following type may be connected:
 602    * @code
 603    *   bool YourCallback( AccessibilityManager& manager );
 604    * @endcode
 605    * @return The signal to connect to.
 606    */
 607   AccessibilityActionSignalType& ActionPageRightSignal();
 608
 609   /**
 610    * @brief This is emitted when accessibility action is received to scroll up to the
 611    * previous page (by one finger swipe left and right)
 612    *
 613    * A callback of the following type may be connected:
 614    * @code
 615    *   bool YourCallback( AccessibilityManager& manager );
 616    * @endcode
 617    * @return The signal to connect to.
 618    */
 619   AccessibilityActionSignalType& ActionPageUpSignal();
 620
 621   /**
 622    * @brief This is emitted when accessibility action is received to scroll down to the
 623    * next page (by one finger swipe right and left)
 624    *
 625    * A callback of the following type may be connected:
 626    * @code
 627    *   bool YourCallback( AccessibilityManager& manager );
 628    * @endcode
 629    * @return The signal to connect to.
 630    */
 631   AccessibilityActionSignalType& ActionPageDownSignal();
 632
 633   /**
 634    * @brief This is emitted when accessibility action is received to move the focus to
 635    * the first item on the screen (by one finger swipe up and down)
 636    *
 637    * A callback of the following type may be connected:
 638    * @code
 639    *   bool YourCallback( AccessibilityManager& manager );
 640    * @endcode
 641    * @return The signal to connect to.
 642    */
 643   AccessibilityActionSignalType& ActionMoveToFirstSignal();
 644
 645   /**
 646    * @brief This is emitted when accessibility action is received to move the focus to
 647    * the last item on the screen (by one finger swipe down and up)
 648    *
 649    * A callback of the following type may be connected:
 650    * @code
 651    *   bool YourCallback( AccessibilityManager& manager );
 652    * @endcode
 653    * @return The signal to connect to.
 654    */
 655   AccessibilityActionSignalType& ActionMoveToLastSignal();
 656
 657   /**
 658    * @brief This is emitted when accessibility action is received to focus and read from the
 659    * first item on the top continously (by three fingers single tap)
 660    *
 661    * A callback of the following type may be connected:
 662    * @code
 663    *   bool YourCallback( AccessibilityManager& manager );
 664    * @endcode
 665    * @return The signal to connect to.
 666    */
 667   AccessibilityActionSignalType& ActionReadFromTopSignal();
 668
 669   /**
 670    * @brief This is emitted when accessibility action is received to move the focus to and
 671    * read from the next item continously (by three fingers double tap)
 672    *
 673    * A callback of the following type may be connected:
 674    * @code
 675    *   bool YourCallback( AccessibilityManager& manager );
 676    * @endcode
 677    * @return The signal to connect to.
 678    */
 679   AccessibilityActionSignalType& ActionReadFromNextSignal();
 680
 681   /**
 682    * @brief This is emitted when accessibility action is received to zoom (by one finger
 683    * triple tap)
 684    *
 685    * A callback of the following type may be connected:
 686    * @code
 687    *   bool YourCallback( AccessibilityManager& manager );
 688    * @endcode
 689    * @return The signal to connect to.
 690    */
 691   AccessibilityActionSignalType& ActionZoomSignal();
 692
 693   /**
 694    * @brief This is emitted when accessibility action is received to read the information
 695    * in the indicator (by two fingers triple tap).
 696    *
 697    * A callback of the following type may be connected:
 698    * @code
 699    *   bool YourCallback( AccessibilityManager& manager );
 700    * @endcode
 701    * @return The signal to connect to.
 702    */
 703   AccessibilityActionSignalType& ActionReadIndicatorInformationSignal();
 704
 705   /**
 706    * @brief This is emitted when accessibility action is received to pause/resume the
 707    * current speech (by two fingers single tap).
 708    *
 709    * A callback of the following type may be connected:
 710    * @code
 711    *   bool YourCallback( AccessibilityManager& manager );
 712    * @endcode
 713    * @return The signal to connect to.
 714    */
 715   AccessibilityActionSignalType& ActionReadPauseResumeSignal();
 716
 717   /**
 718    * @brief This is emitted when accessibility action is received to start/stop the
 719    * current action (by two fingers double tap).
 720    *
 721    * A callback of the following type may be connected:
 722    * @code
 723    *   bool YourCallback( AccessibilityManager& manager );
 724    * @endcode
 725    * @return The signal to connect to.
 726    */
 727   AccessibilityActionSignalType& ActionStartStopSignal();
 728
 729   /**
 730    * @brief This is emitted when accessibility action is received to handle scroll event (by two
 731    * fingers drag).
 732    *
 733    * A callback of the following type may be connected:
 734    * @code
 735    *   bool YourCallback( AccessibilityManager& manager, const TouchEvent& event );
 736    * @endcode
 737    * @return The signal to connect to.
 738    */
 739   AccessibilityActionScrollSignalType& ActionScrollSignal();
 740
 741 public:
 742
 743   explicit DALI_INTERNAL AccessibilityManager( Internal::AccessibilityManager *impl );
 744
 745 }; // class AccessibilityManager
 746
 747 } // namespace Toolkit
 748
 749 } // namespace Dali
 750
 751 #endif // __DALI_TOOLKIT_ACCESSIBILITY_MANAGER_H__