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

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