automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <dali/public-api/object/base-object.h>
  19 #include <dali/devel-api/adaptor-framework/accessibility-adaptor.h>
  20 #include <dali/devel-api/adaptor-framework/accessibility-action-handler.h>
  21 #include <dali/devel-api/adaptor-framework/accessibility-gesture-handler.h>
  22 #include <dali/devel-api/adaptor-framework/accessibility-gesture-event.h>
  23 #include <dali/integration-api/events/touch-integ.h>
  24
  25 namespace Dali
  26 {
  27
  28 namespace Internal
  29 {
  30
  31 namespace Adaptor
  32 {
  33
  34 /**
  35  * Stub for the AccessibilityAdaptor
  36  */
  37 class AccessibilityAdaptor : public BaseObject
  38 {
  39 public: // Creation & Destruction
  40
  41   static Dali::AccessibilityAdaptor Get();
  42
  43   AccessibilityAdaptor();
  44   ~AccessibilityAdaptor();
  45
  46 public:
  47
  48   // Functions to modify mock returns:
  49
  50   void MockSetReadPosition( Vector2& position );
  51
  52   void SetEnabled(bool enabled)
  53   {
  54     mIsEnabled = enabled;
  55   }
  56
  57   void SendPanGesture( const AccessibilityGestureEvent& panEvent );
  58
  59 public:
  60
  61   bool IsEnabled() const;
  62   void SetActionHandler(Dali::AccessibilityActionHandler& handler);
  63   void SetGestureHandler(Dali::AccessibilityGestureHandler& handler);
  64
  65   Vector2 GetReadPosition() const;
  66
  67   bool HandleActionNextEvent(bool);
  68   bool HandleActionPreviousEvent(bool);
  69   bool HandleActionActivateEvent();
  70   bool HandleActionReadEvent(unsigned int x, unsigned int y, bool allowReadAgain);
  71   bool HandleActionReadNextEvent(bool);
  72   bool HandleActionReadPreviousEvent(bool);
  73   bool HandleActionUpEvent();
  74   bool HandleActionDownEvent();
  75   bool HandleActionClearFocusEvent();
  76   bool HandleActionScrollEvent(const TouchPoint& point, unsigned long timeStamp);
  77   bool HandleActionTouchEvent(const TouchPoint& point, unsigned long timeStamp);
  78   bool HandleActionBackEvent();
  79   bool HandleActionEnableEvent();
  80   bool HandleActionDisableEvent();
  81   bool HandleActionScrollUpEvent();
  82   bool HandleActionScrollDownEvent();
  83   bool HandleActionPageLeftEvent();
  84   bool HandleActionPageRightEvent();
  85   bool HandleActionPageUpEvent();
  86   bool HandleActionPageDownEvent();
  87   bool HandleActionMoveToFirstEvent();
  88   bool HandleActionMoveToLastEvent();
  89   bool HandleActionReadFromTopEvent();
  90   bool HandleActionReadFromNextEvent();
  91   bool HandleActionZoomEvent();
  92   bool HandleActionReadPauseResumeEvent();
  93   bool HandleActionStartStopEvent();
  94
  95 private:
  96
  97   bool mIsEnabled;
  98   Dali::AccessibilityActionHandler* mActionHandler;
  99   Dali::AccessibilityGestureHandler* mGestureHandler;
 100   Vector2 mReadPosition;
 101
 102   static Dali::AccessibilityAdaptor mToolkitAccessibilityAdaptor;
 103 };
 104
 105 Dali::AccessibilityAdaptor AccessibilityAdaptor::mToolkitAccessibilityAdaptor;
 106
 107
 108 Dali::AccessibilityAdaptor AccessibilityAdaptor::Get()
 109 {
 110   if( !mToolkitAccessibilityAdaptor )
 111   {
 112     mToolkitAccessibilityAdaptor = Dali::AccessibilityAdaptor( new Dali::Internal::Adaptor::AccessibilityAdaptor() );
 113   }
 114   return mToolkitAccessibilityAdaptor;
 115 }
 116
 117 AccessibilityAdaptor::AccessibilityAdaptor()
 118 : mIsEnabled(false),
 119   mActionHandler(NULL),
 120   mGestureHandler(NULL),
 121   mReadPosition( 0.0f, 0.0f )
 122 {
 123 }
 124
 125 AccessibilityAdaptor::~AccessibilityAdaptor()
 126 {
 127 }
 128
 129 Vector2 AccessibilityAdaptor::GetReadPosition() const
 130 {
 131   return mReadPosition;
 132 }
 133
 134 void AccessibilityAdaptor::MockSetReadPosition( Vector2& position )
 135 {
 136   mReadPosition = position;
 137 }
 138
 139 bool AccessibilityAdaptor::IsEnabled() const
 140 {
 141   return mIsEnabled;
 142 }
 143
 144 void AccessibilityAdaptor::SendPanGesture( const AccessibilityGestureEvent& panEvent )
 145 {
 146   mGestureHandler->HandlePanGesture( panEvent );
 147 }
 148
 149 void AccessibilityAdaptor::SetActionHandler(Dali::AccessibilityActionHandler& handler)
 150 {
 151   mActionHandler = &handler;
 152 }
 153
 154 void AccessibilityAdaptor::SetGestureHandler(Dali::AccessibilityGestureHandler& handler)
 155 {
 156   mGestureHandler = &handler;
 157 }
 158
 159 bool AccessibilityAdaptor::HandleActionNextEvent(bool allowEndFeedback)
 160 {
 161   if( mActionHandler )
 162   {
 163     return mActionHandler->AccessibilityActionNext( true );
 164   }
 165   return false;
 166 }
 167
 168 bool AccessibilityAdaptor::HandleActionPreviousEvent(bool allowEndFeedback)
 169 {
 170   if( mActionHandler )
 171   {
 172     return mActionHandler->AccessibilityActionPrevious( true );
 173   }
 174   return false;
 175 }
 176
 177 bool AccessibilityAdaptor::HandleActionActivateEvent()
 178 {
 179   if( mActionHandler )
 180   {
 181     return mActionHandler->AccessibilityActionActivate();
 182   }
 183   return false;
 184 }
 185
 186 bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y,  bool allowReadAgain)
 187 {
 188   if( mActionHandler )
 189   {
 190     return mActionHandler->AccessibilityActionRead( allowReadAgain );
 191   }
 192   return false;
 193 }
 194
 195 bool AccessibilityAdaptor::HandleActionReadNextEvent(bool allowEndFeedback)
 196 {
 197   if( mActionHandler )
 198   {
 199     return mActionHandler->AccessibilityActionReadNext( true );
 200   }
 201   return false;
 202 }
 203
 204 bool AccessibilityAdaptor::HandleActionReadPreviousEvent(bool allowEndFeedback)
 205 {
 206   if( mActionHandler )
 207   {
 208     return mActionHandler->AccessibilityActionReadPrevious( true );
 209   }
 210   return false;
 211 }
 212
 213 bool AccessibilityAdaptor::HandleActionUpEvent()
 214 {
 215   if( mActionHandler )
 216   {
 217     return mActionHandler->AccessibilityActionUp();
 218   }
 219   return false;
 220 }
 221
 222 bool AccessibilityAdaptor::HandleActionDownEvent()
 223 {
 224   if( mActionHandler )
 225   {
 226     return mActionHandler->AccessibilityActionDown();
 227   }
 228   return false;
 229 }
 230
 231 bool AccessibilityAdaptor::HandleActionClearFocusEvent()
 232 {
 233   if( mActionHandler )
 234   {
 235     return mActionHandler->ClearAccessibilityFocus();
 236   }
 237   return false;
 238 }
 239
 240 bool AccessibilityAdaptor::HandleActionScrollEvent(const TouchPoint& point, unsigned long timeStamp)
 241 {
 242   if( mActionHandler )
 243   {
 244     Dali::TouchEvent touch = Integration::NewTouchEvent(timeStamp, point);
 245     return mActionHandler->AccessibilityActionScroll( touch );
 246   }
 247   return false;
 248 }
 249
 250 bool AccessibilityAdaptor::HandleActionTouchEvent(const TouchPoint& point, unsigned long timeStamp)
 251 {
 252   if( mActionHandler )
 253   {
 254     Dali::TouchEvent touch = Integration::NewTouchEvent(timeStamp, point);
 255     return mActionHandler->AccessibilityActionTouch( touch );
 256   }
 257   return false;
 258 }
 259
 260 bool AccessibilityAdaptor::HandleActionBackEvent()
 261 {
 262   if( mActionHandler )
 263   {
 264     return mActionHandler->AccessibilityActionBack();
 265   }
 266   return false;
 267 }
 268
 269 bool AccessibilityAdaptor::HandleActionEnableEvent()
 270 {
 271   if( mActionHandler )
 272   {
 273     return mActionHandler->ChangeAccessibilityStatus();
 274   }
 275   return false;
 276 }
 277
 278 bool AccessibilityAdaptor::HandleActionDisableEvent()
 279 {
 280   if( mActionHandler )
 281   {
 282     return mActionHandler->ChangeAccessibilityStatus();
 283   }
 284   return false;
 285 }
 286
 287 bool AccessibilityAdaptor::HandleActionScrollUpEvent()
 288 {
 289   if( mActionHandler )
 290   {
 291     return mActionHandler->AccessibilityActionScrollUp();
 292   }
 293   return false;
 294 }
 295
 296 bool AccessibilityAdaptor::HandleActionScrollDownEvent()
 297 {
 298   if( mActionHandler )
 299   {
 300     return mActionHandler->AccessibilityActionScrollDown();
 301   }
 302   return false;
 303 }
 304
 305 bool AccessibilityAdaptor::HandleActionPageLeftEvent()
 306 {
 307   if( mActionHandler )
 308   {
 309     return mActionHandler->AccessibilityActionPageLeft();
 310   }
 311   return false;
 312 }
 313
 314 bool AccessibilityAdaptor::HandleActionPageRightEvent()
 315 {
 316   if( mActionHandler )
 317   {
 318     return mActionHandler->AccessibilityActionPageRight();
 319   }
 320   return false;
 321 }
 322
 323 bool AccessibilityAdaptor::HandleActionPageUpEvent()
 324 {
 325   if( mActionHandler )
 326   {
 327     return mActionHandler->AccessibilityActionPageUp();
 328   }
 329   return false;
 330 }
 331
 332 bool AccessibilityAdaptor::HandleActionPageDownEvent()
 333 {
 334   if( mActionHandler )
 335   {
 336     return mActionHandler->AccessibilityActionPageDown();
 337   }
 338   return false;
 339 }
 340
 341 bool AccessibilityAdaptor::HandleActionMoveToFirstEvent()
 342 {
 343   if( mActionHandler )
 344   {
 345     return mActionHandler->AccessibilityActionMoveToFirst();
 346   }
 347   return false;
 348 }
 349
 350 bool AccessibilityAdaptor::HandleActionMoveToLastEvent()
 351 {
 352   if( mActionHandler )
 353   {
 354     return mActionHandler->AccessibilityActionMoveToLast();
 355   }
 356   return false;
 357 }
 358
 359 bool AccessibilityAdaptor::HandleActionReadFromTopEvent()
 360 {
 361   if( mActionHandler )
 362   {
 363     return mActionHandler->AccessibilityActionReadFromTop();
 364   }
 365   return false;
 366 }
 367
 368 bool AccessibilityAdaptor::HandleActionReadFromNextEvent()
 369 {
 370   if( mActionHandler )
 371   {
 372     return mActionHandler->AccessibilityActionReadFromNext();
 373   }
 374   return false;
 375 }
 376
 377 bool AccessibilityAdaptor::HandleActionZoomEvent()
 378 {
 379   if( mActionHandler )
 380   {
 381     return mActionHandler->AccessibilityActionZoom();
 382   }
 383   return false;
 384 }
 385
 386 bool AccessibilityAdaptor::HandleActionReadPauseResumeEvent()
 387 {
 388   if( mActionHandler )
 389   {
 390     return mActionHandler->AccessibilityActionReadPauseResume();
 391   }
 392   return false;
 393 }
 394
 395 bool AccessibilityAdaptor::HandleActionStartStopEvent()
 396 {
 397   if( mActionHandler )
 398   {
 399     return mActionHandler->AccessibilityActionStartStop();
 400   }
 401   return false;
 402 }
 403
 404 static Internal::Adaptor::AccessibilityAdaptor& GetImplementation(Dali::AccessibilityAdaptor& adaptor)
 405 {
 406   BaseObject& handle = adaptor.GetBaseObject();
 407   return static_cast<Internal::Adaptor::AccessibilityAdaptor&>(handle);
 408 }
 409
 410 static const Internal::Adaptor::AccessibilityAdaptor& GetImplementation(const Dali::AccessibilityAdaptor& adaptor)
 411 {
 412   const BaseObject& handle = adaptor.GetBaseObject();
 413   return static_cast<const Internal::Adaptor::AccessibilityAdaptor&>(handle);
 414 }
 415
 416
 417 } // namespace Adaptor
 418 } // namespace Internal
 419
 420 ////////////////////////////////////////////////////////////////////////////////////////////////////
 421
 422 AccessibilityAdaptor::AccessibilityAdaptor()
 423 {
 424 }
 425
 426 AccessibilityAdaptor AccessibilityAdaptor::Get()
 427 {
 428   return Internal::Adaptor::AccessibilityAdaptor::Get();
 429 }
 430
 431 AccessibilityAdaptor::~AccessibilityAdaptor()
 432 {
 433 }
 434
 435 // Methods:
 436
 437 Vector2 AccessibilityAdaptor::GetReadPosition() const
 438 {
 439   return Internal::Adaptor::GetImplementation(*this).GetReadPosition();
 440 }
 441
 442 bool AccessibilityAdaptor::IsEnabled() const
 443 {
 444   return Internal::Adaptor::GetImplementation(*this).IsEnabled();
 445 }
 446
 447 void AccessibilityAdaptor::SetActionHandler(AccessibilityActionHandler& handler)
 448 {
 449   Internal::Adaptor::GetImplementation(*this).SetActionHandler(handler);
 450 }
 451
 452 void AccessibilityAdaptor::SetGestureHandler(AccessibilityGestureHandler& handler)
 453 {
 454   Internal::Adaptor::GetImplementation(*this).SetGestureHandler(handler);
 455 }
 456
 457 bool AccessibilityAdaptor::HandleActionNextEvent(bool allowEndFeedback)
 458 {
 459   return Internal::Adaptor::GetImplementation(*this).HandleActionNextEvent(allowEndFeedback);
 460 }
 461
 462 bool AccessibilityAdaptor::HandleActionPreviousEvent(bool allowEndFeedback)
 463 {
 464   return Internal::Adaptor::GetImplementation(*this).HandleActionPreviousEvent(allowEndFeedback);
 465 }
 466
 467 bool AccessibilityAdaptor::HandleActionActivateEvent()
 468 {
 469   return Internal::Adaptor::GetImplementation(*this).HandleActionActivateEvent();
 470 }
 471
 472 bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y,  bool allowReadAgain)
 473 {
 474   return Internal::Adaptor::GetImplementation(*this).HandleActionReadEvent( x, y, allowReadAgain );
 475 }
 476
 477 bool AccessibilityAdaptor::HandleActionReadNextEvent(bool allowEndFeedback)
 478 {
 479   return Internal::Adaptor::GetImplementation(*this).HandleActionReadNextEvent(allowEndFeedback);
 480 }
 481
 482 bool AccessibilityAdaptor::HandleActionReadPreviousEvent(bool allowEndFeedback)
 483 {
 484   return Internal::Adaptor::GetImplementation(*this).HandleActionReadPreviousEvent(allowEndFeedback);
 485 }
 486
 487 bool AccessibilityAdaptor::HandleActionUpEvent()
 488 {
 489   return Internal::Adaptor::GetImplementation(*this).HandleActionUpEvent();
 490 }
 491
 492 bool AccessibilityAdaptor::HandleActionDownEvent()
 493 {
 494   return Internal::Adaptor::GetImplementation(*this).HandleActionDownEvent();
 495 }
 496
 497 bool AccessibilityAdaptor::HandleActionClearFocusEvent()
 498 {
 499   return Internal::Adaptor::GetImplementation(*this).HandleActionClearFocusEvent();
 500 }
 501
 502 bool AccessibilityAdaptor::HandleActionScrollEvent(const TouchPoint& point, unsigned long timeStamp)
 503 {
 504   return Internal::Adaptor::GetImplementation(*this).HandleActionScrollEvent(point, timeStamp);
 505 }
 506
 507 bool AccessibilityAdaptor::HandleActionTouchEvent(const TouchPoint& point, unsigned long timeStamp)
 508 {
 509   return Internal::Adaptor::GetImplementation(*this).HandleActionTouchEvent(point, timeStamp);
 510 }
 511
 512 bool AccessibilityAdaptor::HandleActionBackEvent()
 513 {
 514   return Internal::Adaptor::GetImplementation(*this).HandleActionBackEvent();
 515 }
 516
 517 void AccessibilityAdaptor::HandleActionEnableEvent()
 518 {
 519   Internal::Adaptor::GetImplementation(*this).HandleActionEnableEvent();
 520 }
 521
 522 void AccessibilityAdaptor::HandleActionDisableEvent()
 523 {
 524   Internal::Adaptor::GetImplementation(*this).HandleActionDisableEvent();
 525 }
 526
 527 bool AccessibilityAdaptor::HandleActionScrollUpEvent()
 528 {
 529   return Internal::Adaptor::GetImplementation(*this).HandleActionScrollUpEvent();
 530 }
 531
 532 bool AccessibilityAdaptor::HandleActionScrollDownEvent()
 533 {
 534   return Internal::Adaptor::GetImplementation(*this).HandleActionScrollDownEvent();
 535 }
 536
 537 bool AccessibilityAdaptor::HandleActionPageLeftEvent()
 538 {
 539   return Internal::Adaptor::GetImplementation(*this).HandleActionPageLeftEvent();
 540 }
 541
 542 bool AccessibilityAdaptor::HandleActionPageRightEvent()
 543 {
 544   return Internal::Adaptor::GetImplementation(*this).HandleActionPageRightEvent();
 545 }
 546
 547 bool AccessibilityAdaptor::HandleActionPageUpEvent()
 548 {
 549   return Internal::Adaptor::GetImplementation(*this).HandleActionPageUpEvent();
 550 }
 551
 552 bool AccessibilityAdaptor::HandleActionPageDownEvent()
 553 {
 554   return Internal::Adaptor::GetImplementation(*this).HandleActionPageDownEvent();
 555 }
 556
 557 bool AccessibilityAdaptor::HandleActionMoveToFirstEvent()
 558 {
 559   return Internal::Adaptor::GetImplementation(*this).HandleActionMoveToFirstEvent();
 560 }
 561
 562 bool AccessibilityAdaptor::HandleActionMoveToLastEvent()
 563 {
 564   return Internal::Adaptor::GetImplementation(*this).HandleActionMoveToLastEvent();
 565 }
 566
 567 bool AccessibilityAdaptor::HandleActionReadFromTopEvent()
 568 {
 569   return Internal::Adaptor::GetImplementation(*this).HandleActionReadFromTopEvent();
 570 }
 571
 572 bool AccessibilityAdaptor::HandleActionReadFromNextEvent()
 573 {
 574   return Internal::Adaptor::GetImplementation(*this).HandleActionReadFromNextEvent();
 575 }
 576
 577 bool AccessibilityAdaptor::HandleActionZoomEvent()
 578 {
 579   return Internal::Adaptor::GetImplementation(*this).HandleActionZoomEvent();
 580 }
 581
 582 bool AccessibilityAdaptor::HandleActionReadPauseResumeEvent()
 583 {
 584   return Internal::Adaptor::GetImplementation(*this).HandleActionReadPauseResumeEvent();
 585 }
 586
 587 bool AccessibilityAdaptor::HandleActionStartStopEvent()
 588 {
 589   return Internal::Adaptor::GetImplementation(*this).HandleActionStartStopEvent();
 590 }
 591
 592 AccessibilityAdaptor::AccessibilityAdaptor( Internal::Adaptor::AccessibilityAdaptor* adaptor )
 593 : BaseHandle( adaptor )
 594 {
 595 }
 596
 597 } // namespace Dali
 598
 599
 600 namespace Test
 601 {
 602 namespace AccessibilityAdaptor
 603 {
 604
 605 // Mock setup:
 606
 607 void MockSetReadPosition( Dali::AccessibilityAdaptor adaptor, Dali::Vector2& position )
 608 {
 609   Dali::Internal::Adaptor::GetImplementation(adaptor).MockSetReadPosition( position );
 610 }
 611
 612 void SetEnabled( Dali::AccessibilityAdaptor adaptor, bool enabled )
 613 {
 614   Dali::Internal::Adaptor::GetImplementation(adaptor).SetEnabled(enabled);
 615 }
 616
 617 void SendPanGesture( Dali::AccessibilityAdaptor adaptor, const Dali::AccessibilityGestureEvent& panEvent )
 618 {
 619   Dali::Internal::Adaptor::GetImplementation(adaptor).SendPanGesture( panEvent );
 620 }
 621
 622 } // namespace AccessibilityAdaptor
 623 } // namespace Test