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 HandleActionBackEvent();
  78   bool HandleActionEnableEvent();
  79   bool HandleActionDisableEvent();
  80   bool HandleActionScrollUpEvent();
  81   bool HandleActionScrollDownEvent();
  82   bool HandleActionPageLeftEvent();
  83   bool HandleActionPageRightEvent();
  84   bool HandleActionPageUpEvent();
  85   bool HandleActionPageDownEvent();
  86   bool HandleActionMoveToFirstEvent();
  87   bool HandleActionMoveToLastEvent();
  88   bool HandleActionReadFromTopEvent();
  89   bool HandleActionReadFromNextEvent();
  90   bool HandleActionZoomEvent();
  91   bool HandleActionReadPauseResumeEvent();
  92   bool HandleActionStartStopEvent();
  93
  94 private:
  95
  96   bool mIsEnabled;
  97   Dali::AccessibilityActionHandler* mActionHandler;
  98   Dali::AccessibilityGestureHandler* mGestureHandler;
  99   Vector2 mReadPosition;
 100
 101   static Dali::AccessibilityAdaptor mToolkitAccessibilityAdaptor;
 102 };
 103
 104 Dali::AccessibilityAdaptor AccessibilityAdaptor::mToolkitAccessibilityAdaptor;
 105
 106
 107 Dali::AccessibilityAdaptor AccessibilityAdaptor::Get()
 108 {
 109   if( !mToolkitAccessibilityAdaptor )
 110   {
 111     mToolkitAccessibilityAdaptor = Dali::AccessibilityAdaptor( new Dali::Internal::Adaptor::AccessibilityAdaptor() );
 112   }
 113   return mToolkitAccessibilityAdaptor;
 114 }
 115
 116 AccessibilityAdaptor::AccessibilityAdaptor()
 117 : mIsEnabled(false),
 118   mActionHandler(NULL),
 119   mGestureHandler(NULL),
 120   mReadPosition( 0.0f, 0.0f )
 121 {
 122 }
 123
 124 AccessibilityAdaptor::~AccessibilityAdaptor()
 125 {
 126 }
 127
 128 Vector2 AccessibilityAdaptor::GetReadPosition() const
 129 {
 130   return mReadPosition;
 131 }
 132
 133 void AccessibilityAdaptor::MockSetReadPosition( Vector2& position )
 134 {
 135   mReadPosition = position;
 136 }
 137
 138 bool AccessibilityAdaptor::IsEnabled() const
 139 {
 140   return mIsEnabled;
 141 }
 142
 143 void AccessibilityAdaptor::SendPanGesture( const AccessibilityGestureEvent& panEvent )
 144 {
 145   mGestureHandler->HandlePanGesture( panEvent );
 146 }
 147
 148 void AccessibilityAdaptor::SetActionHandler(Dali::AccessibilityActionHandler& handler)
 149 {
 150   mActionHandler = &handler;
 151 }
 152
 153 void AccessibilityAdaptor::SetGestureHandler(Dali::AccessibilityGestureHandler& handler)
 154 {
 155   mGestureHandler = &handler;
 156 }
 157
 158 bool AccessibilityAdaptor::HandleActionNextEvent(bool allowEndFeedback)
 159 {
 160   if( mActionHandler )
 161   {
 162     return mActionHandler->AccessibilityActionNext( true );
 163   }
 164   return false;
 165 }
 166
 167 bool AccessibilityAdaptor::HandleActionPreviousEvent(bool allowEndFeedback)
 168 {
 169   if( mActionHandler )
 170   {
 171     return mActionHandler->AccessibilityActionPrevious( true );
 172   }
 173   return false;
 174 }
 175
 176 bool AccessibilityAdaptor::HandleActionActivateEvent()
 177 {
 178   if( mActionHandler )
 179   {
 180     return mActionHandler->AccessibilityActionActivate();
 181   }
 182   return false;
 183 }
 184
 185 bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y,  bool allowReadAgain)
 186 {
 187   if( mActionHandler )
 188   {
 189     return mActionHandler->AccessibilityActionRead( allowReadAgain );
 190   }
 191   return false;
 192 }
 193
 194 bool AccessibilityAdaptor::HandleActionReadNextEvent(bool allowEndFeedback)
 195 {
 196   if( mActionHandler )
 197   {
 198     return mActionHandler->AccessibilityActionReadNext( true );
 199   }
 200   return false;
 201 }
 202
 203 bool AccessibilityAdaptor::HandleActionReadPreviousEvent(bool allowEndFeedback)
 204 {
 205   if( mActionHandler )
 206   {
 207     return mActionHandler->AccessibilityActionReadPrevious( true );
 208   }
 209   return false;
 210 }
 211
 212 bool AccessibilityAdaptor::HandleActionUpEvent()
 213 {
 214   if( mActionHandler )
 215   {
 216     return mActionHandler->AccessibilityActionUp();
 217   }
 218   return false;
 219 }
 220
 221 bool AccessibilityAdaptor::HandleActionDownEvent()
 222 {
 223   if( mActionHandler )
 224   {
 225     return mActionHandler->AccessibilityActionDown();
 226   }
 227   return false;
 228 }
 229
 230 bool AccessibilityAdaptor::HandleActionClearFocusEvent()
 231 {
 232   if( mActionHandler )
 233   {
 234     return mActionHandler->ClearAccessibilityFocus();
 235   }
 236   return false;
 237 }
 238
 239 bool AccessibilityAdaptor::HandleActionScrollEvent(const TouchPoint& point, unsigned long timeStamp)
 240 {
 241   if( mActionHandler )
 242   {
 243     Dali::TouchEvent touch = Integration::NewTouchEvent(timeStamp, point);
 244     return mActionHandler->AccessibilityActionScroll( touch );
 245   }
 246   return false;
 247 }
 248
 249 bool AccessibilityAdaptor::HandleActionBackEvent()
 250 {
 251   if( mActionHandler )
 252   {
 253     return mActionHandler->AccessibilityActionBack();
 254   }
 255   return false;
 256 }
 257
 258 bool AccessibilityAdaptor::HandleActionEnableEvent()
 259 {
 260   if( mActionHandler )
 261   {
 262     return mActionHandler->ChangeAccessibilityStatus();
 263   }
 264   return false;
 265 }
 266
 267 bool AccessibilityAdaptor::HandleActionDisableEvent()
 268 {
 269   if( mActionHandler )
 270   {
 271     return mActionHandler->ChangeAccessibilityStatus();
 272   }
 273   return false;
 274 }
 275
 276 bool AccessibilityAdaptor::HandleActionScrollUpEvent()
 277 {
 278   if( mActionHandler )
 279   {
 280     return mActionHandler->AccessibilityActionScrollUp();
 281   }
 282   return false;
 283 }
 284
 285 bool AccessibilityAdaptor::HandleActionScrollDownEvent()
 286 {
 287   if( mActionHandler )
 288   {
 289     return mActionHandler->AccessibilityActionScrollDown();
 290   }
 291   return false;
 292 }
 293
 294 bool AccessibilityAdaptor::HandleActionPageLeftEvent()
 295 {
 296   if( mActionHandler )
 297   {
 298     return mActionHandler->AccessibilityActionPageLeft();
 299   }
 300   return false;
 301 }
 302
 303 bool AccessibilityAdaptor::HandleActionPageRightEvent()
 304 {
 305   if( mActionHandler )
 306   {
 307     return mActionHandler->AccessibilityActionPageRight();
 308   }
 309   return false;
 310 }
 311
 312 bool AccessibilityAdaptor::HandleActionPageUpEvent()
 313 {
 314   if( mActionHandler )
 315   {
 316     return mActionHandler->AccessibilityActionPageUp();
 317   }
 318   return false;
 319 }
 320
 321 bool AccessibilityAdaptor::HandleActionPageDownEvent()
 322 {
 323   if( mActionHandler )
 324   {
 325     return mActionHandler->AccessibilityActionPageDown();
 326   }
 327   return false;
 328 }
 329
 330 bool AccessibilityAdaptor::HandleActionMoveToFirstEvent()
 331 {
 332   if( mActionHandler )
 333   {
 334     return mActionHandler->AccessibilityActionMoveToFirst();
 335   }
 336   return false;
 337 }
 338
 339 bool AccessibilityAdaptor::HandleActionMoveToLastEvent()
 340 {
 341   if( mActionHandler )
 342   {
 343     return mActionHandler->AccessibilityActionMoveToLast();
 344   }
 345   return false;
 346 }
 347
 348 bool AccessibilityAdaptor::HandleActionReadFromTopEvent()
 349 {
 350   if( mActionHandler )
 351   {
 352     return mActionHandler->AccessibilityActionReadFromTop();
 353   }
 354   return false;
 355 }
 356
 357 bool AccessibilityAdaptor::HandleActionReadFromNextEvent()
 358 {
 359   if( mActionHandler )
 360   {
 361     return mActionHandler->AccessibilityActionReadFromNext();
 362   }
 363   return false;
 364 }
 365
 366 bool AccessibilityAdaptor::HandleActionZoomEvent()
 367 {
 368   if( mActionHandler )
 369   {
 370     return mActionHandler->AccessibilityActionZoom();
 371   }
 372   return false;
 373 }
 374
 375 bool AccessibilityAdaptor::HandleActionReadPauseResumeEvent()
 376 {
 377   if( mActionHandler )
 378   {
 379     return mActionHandler->AccessibilityActionReadPauseResume();
 380   }
 381   return false;
 382 }
 383
 384 bool AccessibilityAdaptor::HandleActionStartStopEvent()
 385 {
 386   if( mActionHandler )
 387   {
 388     return mActionHandler->AccessibilityActionStartStop();
 389   }
 390   return false;
 391 }
 392
 393 static Internal::Adaptor::AccessibilityAdaptor& GetImplementation(Dali::AccessibilityAdaptor& adaptor)
 394 {
 395   BaseObject& handle = adaptor.GetBaseObject();
 396   return static_cast<Internal::Adaptor::AccessibilityAdaptor&>(handle);
 397 }
 398
 399 static const Internal::Adaptor::AccessibilityAdaptor& GetImplementation(const Dali::AccessibilityAdaptor& adaptor)
 400 {
 401   const BaseObject& handle = adaptor.GetBaseObject();
 402   return static_cast<const Internal::Adaptor::AccessibilityAdaptor&>(handle);
 403 }
 404
 405
 406 } // namespace Adaptor
 407 } // namespace Internal
 408
 409 ////////////////////////////////////////////////////////////////////////////////////////////////////
 410
 411 AccessibilityAdaptor::AccessibilityAdaptor()
 412 {
 413 }
 414
 415 AccessibilityAdaptor AccessibilityAdaptor::Get()
 416 {
 417   return Internal::Adaptor::AccessibilityAdaptor::Get();
 418 }
 419
 420 AccessibilityAdaptor::~AccessibilityAdaptor()
 421 {
 422 }
 423
 424 // Methods:
 425
 426 Vector2 AccessibilityAdaptor::GetReadPosition() const
 427 {
 428   return Internal::Adaptor::GetImplementation(*this).GetReadPosition();
 429 }
 430
 431 bool AccessibilityAdaptor::IsEnabled() const
 432 {
 433   return Internal::Adaptor::GetImplementation(*this).IsEnabled();
 434 }
 435
 436 void AccessibilityAdaptor::SetActionHandler(AccessibilityActionHandler& handler)
 437 {
 438   Internal::Adaptor::GetImplementation(*this).SetActionHandler(handler);
 439 }
 440
 441 void AccessibilityAdaptor::SetGestureHandler(AccessibilityGestureHandler& handler)
 442 {
 443   Internal::Adaptor::GetImplementation(*this).SetGestureHandler(handler);
 444 }
 445
 446 bool AccessibilityAdaptor::HandleActionNextEvent(bool allowEndFeedback)
 447 {
 448   return Internal::Adaptor::GetImplementation(*this).HandleActionNextEvent(allowEndFeedback);
 449 }
 450
 451 bool AccessibilityAdaptor::HandleActionPreviousEvent(bool allowEndFeedback)
 452 {
 453   return Internal::Adaptor::GetImplementation(*this).HandleActionPreviousEvent(allowEndFeedback);
 454 }
 455
 456 bool AccessibilityAdaptor::HandleActionActivateEvent()
 457 {
 458   return Internal::Adaptor::GetImplementation(*this).HandleActionActivateEvent();
 459 }
 460
 461 bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y,  bool allowReadAgain)
 462 {
 463   return Internal::Adaptor::GetImplementation(*this).HandleActionReadEvent( x, y, allowReadAgain );
 464 }
 465
 466 bool AccessibilityAdaptor::HandleActionReadNextEvent(bool allowEndFeedback)
 467 {
 468   return Internal::Adaptor::GetImplementation(*this).HandleActionReadNextEvent(allowEndFeedback);
 469 }
 470
 471 bool AccessibilityAdaptor::HandleActionReadPreviousEvent(bool allowEndFeedback)
 472 {
 473   return Internal::Adaptor::GetImplementation(*this).HandleActionReadPreviousEvent(allowEndFeedback);
 474 }
 475
 476 bool AccessibilityAdaptor::HandleActionUpEvent()
 477 {
 478   return Internal::Adaptor::GetImplementation(*this).HandleActionUpEvent();
 479 }
 480
 481 bool AccessibilityAdaptor::HandleActionDownEvent()
 482 {
 483   return Internal::Adaptor::GetImplementation(*this).HandleActionDownEvent();
 484 }
 485
 486 bool AccessibilityAdaptor::HandleActionClearFocusEvent()
 487 {
 488   return Internal::Adaptor::GetImplementation(*this).HandleActionClearFocusEvent();
 489 }
 490
 491 bool AccessibilityAdaptor::HandleActionScrollEvent(const TouchPoint& point, unsigned long timeStamp)
 492 {
 493   return Internal::Adaptor::GetImplementation(*this).HandleActionScrollEvent(point, timeStamp);
 494 }
 495
 496 bool AccessibilityAdaptor::HandleActionBackEvent()
 497 {
 498   return Internal::Adaptor::GetImplementation(*this).HandleActionBackEvent();
 499 }
 500
 501 void AccessibilityAdaptor::HandleActionEnableEvent()
 502 {
 503   Internal::Adaptor::GetImplementation(*this).HandleActionEnableEvent();
 504 }
 505
 506 void AccessibilityAdaptor::HandleActionDisableEvent()
 507 {
 508   Internal::Adaptor::GetImplementation(*this).HandleActionDisableEvent();
 509 }
 510
 511 bool AccessibilityAdaptor::HandleActionScrollUpEvent()
 512 {
 513   return Internal::Adaptor::GetImplementation(*this).HandleActionScrollUpEvent();
 514 }
 515
 516 bool AccessibilityAdaptor::HandleActionScrollDownEvent()
 517 {
 518   return Internal::Adaptor::GetImplementation(*this).HandleActionScrollDownEvent();
 519 }
 520
 521 bool AccessibilityAdaptor::HandleActionPageLeftEvent()
 522 {
 523   return Internal::Adaptor::GetImplementation(*this).HandleActionPageLeftEvent();
 524 }
 525
 526 bool AccessibilityAdaptor::HandleActionPageRightEvent()
 527 {
 528   return Internal::Adaptor::GetImplementation(*this).HandleActionPageRightEvent();
 529 }
 530
 531 bool AccessibilityAdaptor::HandleActionPageUpEvent()
 532 {
 533   return Internal::Adaptor::GetImplementation(*this).HandleActionPageUpEvent();
 534 }
 535
 536 bool AccessibilityAdaptor::HandleActionPageDownEvent()
 537 {
 538   return Internal::Adaptor::GetImplementation(*this).HandleActionPageDownEvent();
 539 }
 540
 541 bool AccessibilityAdaptor::HandleActionMoveToFirstEvent()
 542 {
 543   return Internal::Adaptor::GetImplementation(*this).HandleActionMoveToFirstEvent();
 544 }
 545
 546 bool AccessibilityAdaptor::HandleActionMoveToLastEvent()
 547 {
 548   return Internal::Adaptor::GetImplementation(*this).HandleActionMoveToLastEvent();
 549 }
 550
 551 bool AccessibilityAdaptor::HandleActionReadFromTopEvent()
 552 {
 553   return Internal::Adaptor::GetImplementation(*this).HandleActionReadFromTopEvent();
 554 }
 555
 556 bool AccessibilityAdaptor::HandleActionReadFromNextEvent()
 557 {
 558   return Internal::Adaptor::GetImplementation(*this).HandleActionReadFromNextEvent();
 559 }
 560
 561 bool AccessibilityAdaptor::HandleActionZoomEvent()
 562 {
 563   return Internal::Adaptor::GetImplementation(*this).HandleActionZoomEvent();
 564 }
 565
 566 bool AccessibilityAdaptor::HandleActionReadPauseResumeEvent()
 567 {
 568   return Internal::Adaptor::GetImplementation(*this).HandleActionReadPauseResumeEvent();
 569 }
 570
 571 bool AccessibilityAdaptor::HandleActionStartStopEvent()
 572 {
 573   return Internal::Adaptor::GetImplementation(*this).HandleActionStartStopEvent();
 574 }
 575
 576 AccessibilityAdaptor::AccessibilityAdaptor( Internal::Adaptor::AccessibilityAdaptor* adaptor )
 577 : BaseHandle( adaptor )
 578 {
 579 }
 580
 581 } // namespace Dali
 582
 583
 584 namespace Test
 585 {
 586 namespace AccessibilityAdaptor
 587 {
 588
 589 // Mock setup:
 590
 591 void MockSetReadPosition( Dali::AccessibilityAdaptor adaptor, Dali::Vector2& position )
 592 {
 593   Dali::Internal::Adaptor::GetImplementation(adaptor).MockSetReadPosition( position );
 594 }
 595
 596 void SetEnabled( Dali::AccessibilityAdaptor adaptor, bool enabled )
 597 {
 598   Dali::Internal::Adaptor::GetImplementation(adaptor).SetEnabled(enabled);
 599 }
 600
 601 void SendPanGesture( Dali::AccessibilityAdaptor adaptor, const Dali::AccessibilityGestureEvent& panEvent )
 602 {
 603   Dali::Internal::Adaptor::GetImplementation(adaptor).SendPanGesture( panEvent );
 604 }
 605
 606 } // namespace AccessibilityAdaptor
 607 } // namespace Test