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