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