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