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