dali-toolkit/public-api/accessibility-manager/accessibility-manager.h

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