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