automated-tests/src/dali-toolkit/utc-Dali-KeyInputFocusManager.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 <iostream>
  19 #include <stdlib.h>
  20 #include <dali-toolkit-test-suite-utils.h>
  21 #include <dali-toolkit/dali-toolkit.h>
  22 #include <dali/integration-api/events/key-event-integ.h>
  23 #include <dali-toolkit/devel-api/controls/control-devel.h>
  24 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
  25 #include <dali/devel-api/common/stage-devel.h>
  26
  27 #include "dummy-control.h"
  28
  29 using namespace Dali;
  30 using namespace Toolkit;
  31
  32 namespace
  33 {
  34
  35 /**
  36  * Callback class for KeyInputFocusChanged signal.
  37  */
  38 class KeyInputFocusChangedCallback : public Dali::ConnectionTracker
  39 {
  40 public:
  41   /**
  42    * Constructor
  43    * @param[in]  gainActor  Ref to the actor that should be set as the one that gains key input focus.
  44    * @param[in]  lostActor  Ref to the actor that should be set as the one that loses key input focus.
  45    */
  46   KeyInputFocusChangedCallback( Control& gainActor, Control& lostActor )
  47   : mActorGain( gainActor ),
  48     mActorLost( lostActor )
  49   {
  50   }
  51
  52   void Callback( Control gainingActor, Control lostActor )
  53   {
  54     mActorGain = gainingActor;
  55     mActorLost = lostActor;
  56   }
  57
  58   Control& mActorGain;
  59   Control& mActorLost;
  60 };
  61
  62 // Stores data that is populated in the callback and will be read by the TET cases
  63 struct SignalData
  64 {
  65   SignalData()
  66   : functorCalled(false)
  67   {}
  68
  69   void Reset()
  70   {
  71     functorCalled = false;
  72
  73     receivedKeyEvent.Reset();
  74
  75   }
  76
  77   bool functorCalled;
  78   KeyEvent receivedKeyEvent;
  79 };
  80
  81 /**
  82  * Callback class for KeyEvent signal of control.
  83  */
  84 class KeyEventCallback : public Dali::ConnectionTracker
  85 {
  86 public:
  87   /**
  88    * Constructor
  89    * @param[in]  returnValue  Set return value of KeyEvent callback.
  90    * */
  91   KeyEventCallback( bool consumed )
  92   : mConsumed( consumed ),
  93     mIsCalled( false )
  94   {
  95   }
  96
  97   bool Callback( Control control, const KeyEvent& keyEvent )
  98   {
  99     mIsCalled = true;
 100     return mConsumed;
 101   }
 102
 103   void Callback( const KeyEvent& keyEvent )
 104   {
 105     mIsCalled = true;
 106   }
 107
 108   bool mConsumed;
 109   bool mIsCalled;
 110 };
 111
 112 } // namespace
 113
 114 void key_input_focus_manager_startup(void)
 115 {
 116   test_return_value = TET_UNDEF;
 117 }
 118
 119 void key_input_focus_manager_cleanup(void)
 120 {
 121   test_return_value = TET_PASS;
 122 }
 123
 124 int UtcDaliKeyInputFocusManagerGet(void)
 125 {
 126   ToolkitTestApplication application;
 127
 128   tet_infoline(" UtcDaliKeyInputFocusManagerGet");
 129
 130   KeyInputFocusManager manager;
 131   {
 132     manager = KeyInputFocusManager::Get();
 133     DALI_TEST_CHECK(manager);
 134   }
 135
 136   KeyInputFocusManager newManager = KeyInputFocusManager::Get();
 137   DALI_TEST_CHECK(newManager);
 138
 139   // Check that focus manager is a singleton
 140   DALI_TEST_CHECK(manager == newManager);
 141
 142   END_TEST;
 143 }
 144
 145 int UtcDaliKeyInputFocusManagerSetFocus01(void)
 146 {
 147   ToolkitTestApplication application;
 148   Integration::Scene stage = application.GetScene();
 149
 150   tet_infoline(" Check that there is no focused control. Set focus to control. Check it is now the focused actor and receives KeyInputFocusGained signal");
 151
 152   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 153   DALI_TEST_CHECK(manager);
 154
 155   Control focusedControl = manager.GetCurrentFocusControl();
 156   DALI_TEST_CHECK( ! focusedControl );
 157
 158   DummyControl dummy = DummyControl::New(true);
 159   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
 160   dummy.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 161   stage.Add( dummy );
 162   DALI_TEST_CHECK( ! dummyImpl.keyInputFocusGained );
 163
 164   manager.SetFocus( dummy );
 165   DALI_TEST_CHECK( dummy.HasKeyInputFocus()); // Also tests IsKeyboardListener() API
 166   DALI_TEST_CHECK( dummyImpl.keyInputFocusGained );
 167
 168   focusedControl = manager.GetCurrentFocusControl();
 169   DALI_TEST_CHECK( focusedControl );
 170   DALI_TEST_CHECK( focusedControl == dummy );
 171
 172   END_TEST;
 173 }
 174
 175 int UtcDaliKeyInputFocusManagerSetFocus02(void)
 176 {
 177   ToolkitTestApplication application;
 178   Integration::Scene stage = application.GetScene();
 179
 180   tet_infoline(" Set focus to control. Check it is now the focused actor and receives KeyInputFocusGained signal. Set focuse to another control - check that the first control receives KeyInputFocusLost");
 181
 182   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 183   DALI_TEST_CHECK(manager);
 184
 185   DummyControl dummy1 = DummyControl::New(true);
 186   Impl::DummyControl& dummy1Impl = static_cast<Impl::DummyControl&>(dummy1.GetImplementation());
 187   dummy1.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 188   stage.Add( dummy1 );
 189   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusGained );
 190   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusLost );
 191
 192   manager.SetFocus( dummy1 );
 193   DALI_TEST_CHECK( dummy1.HasKeyInputFocus()); // Also tests IsKeyboardListener() API
 194   DALI_TEST_CHECK( dummy1Impl.keyInputFocusGained );
 195   dummy1Impl.keyInputFocusGained = false;
 196
 197   DummyControl dummy2 = DummyControl::New(true);
 198   Impl::DummyControl& dummy2Impl = static_cast<Impl::DummyControl&>(dummy2.GetImplementation());
 199   dummy2.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 200   stage.Add( dummy2 );
 201   DALI_TEST_CHECK( ! dummy2Impl.keyInputFocusGained );
 202   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusLost );
 203
 204   manager.SetFocus( dummy2 );
 205   DALI_TEST_CHECK( dummy2.HasKeyInputFocus()); // Also tests IsKeyboardListener() API
 206   DALI_TEST_CHECK( dummy2Impl.keyInputFocusGained );
 207   dummy1Impl.keyInputFocusGained = false;
 208
 209   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusGained );
 210   DALI_TEST_CHECK( dummy1Impl.keyInputFocusLost );
 211
 212   END_TEST;
 213 }
 214
 215 int UtcDaliKeyInputFocusManagerKeyEventPropagation01(void)
 216 {
 217
 218   ToolkitTestApplication application;
 219   Integration::Scene stage = application.GetScene();
 220
 221   tet_infoline("Test KeyEvent propagation. If focused control doesn't consume KeyEvent, KeyEvent will be recursively delivered to the control and its parents, until the event is consumed or the stage is reached. In this case, KeyEvent is delivered to KeyboardFocusManager via Stage's KeyEventSignal");
 222
 223   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 224   DALI_TEST_CHECK(manager);
 225
 226   KeyEventCallback stageCallback( false );
 227   stage.KeyEventSignal().Connect( &stageCallback, &KeyEventCallback::Callback );
 228
 229   DummyControl dummy1 = DummyControl::New(true);
 230   dummy1.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 231   KeyEventCallback callback1( false );
 232   dummy1.KeyEventSignal().Connect( &callback1, &KeyEventCallback::Callback );
 233   stage.Add( dummy1 );
 234
 235   DummyControl dummy2 = DummyControl::New(true);
 236   dummy2.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 237   KeyEventCallback callback2( false );
 238   dummy2.KeyEventSignal().Connect( &callback2, &KeyEventCallback::Callback );
 239   dummy1.Add( dummy2 );
 240
 241   DummyControl dummy3 = DummyControl::New(true);
 242   Impl::DummyControl& dummy3Impl = static_cast<Impl::DummyControl&>(dummy3.GetImplementation());
 243   dummy3.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 244   KeyEventCallback callback3( false );
 245   dummy3.KeyEventSignal().Connect( &callback3, &KeyEventCallback::Callback );
 246   dummy2.Add( dummy3 );
 247   DALI_TEST_CHECK( ! dummy3Impl.keyInputFocusGained );
 248   DALI_TEST_CHECK( ! dummy3Impl.keyInputFocusLost );
 249
 250   manager.SetFocus( dummy3 );
 251   DALI_TEST_CHECK( dummy3Impl.keyInputFocusGained );
 252
 253   Integration::KeyEvent event( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "", "", Device::Class::TOUCH, Device::Subclass::NONE );
 254   application.ProcessEvent(event);
 255
 256   DALI_TEST_CHECK( callback1.mIsCalled );
 257   DALI_TEST_CHECK( callback2.mIsCalled );
 258   DALI_TEST_CHECK( callback3.mIsCalled );
 259   DALI_TEST_CHECK( stageCallback.mIsCalled );
 260
 261   END_TEST;
 262 }
 263
 264 int UtcDaliKeyInputFocusManagerKeyEventPropagation02(void)
 265 {
 266
 267   ToolkitTestApplication application;
 268   Integration::Scene stage = application.GetScene();
 269
 270   tet_infoline("Test KeyEvent propagation. If focused control doesn't consume KeyEvent, KeyEvent will be recursively delivered to the control and its parents, until the event is consumed or the stage is reached. In this case, KeyEvent is delivered from dummy3 to dummy2");
 271
 272   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 273   DALI_TEST_CHECK(manager);
 274
 275   DummyControl dummy1 = DummyControl::New(true);
 276   dummy1.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 277   KeyEventCallback callback1( false );
 278   dummy1.KeyEventSignal().Connect( &callback1, &KeyEventCallback::Callback );
 279   stage.Add( dummy1 );
 280
 281   DummyControl dummy2 = DummyControl::New(true);
 282   dummy2.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 283   KeyEventCallback callback2( true );
 284   dummy2.KeyEventSignal().Connect( &callback2, &KeyEventCallback::Callback );
 285   dummy1.Add( dummy2 );
 286
 287   DummyControl dummy3 = DummyControl::New(true);
 288   Impl::DummyControl& dummy3Impl = static_cast<Impl::DummyControl&>(dummy3.GetImplementation());
 289   dummy3.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 290   KeyEventCallback callback3( false );
 291   dummy3.KeyEventSignal().Connect( &callback3, &KeyEventCallback::Callback );
 292   dummy2.Add( dummy3 );
 293   DALI_TEST_CHECK( ! dummy3Impl.keyInputFocusGained );
 294   DALI_TEST_CHECK( ! dummy3Impl.keyInputFocusLost );
 295
 296   manager.SetFocus( dummy3 );
 297   DALI_TEST_CHECK( dummy3Impl.keyInputFocusGained );
 298
 299   Integration::KeyEvent event( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "", "", Device::Class::TOUCH, Device::Subclass::NONE );
 300   application.ProcessEvent(event);
 301
 302   DALI_TEST_CHECK( !callback1.mIsCalled );
 303   DALI_TEST_CHECK( callback2.mIsCalled );
 304   DALI_TEST_CHECK( callback3.mIsCalled );
 305
 306   END_TEST;
 307 }
 308
 309 int UtcDaliKeyInputFocusManagerDispatchKeyEvents(void)
 310 {
 311
 312   ToolkitTestApplication application;
 313   Integration::Scene stage = application.GetScene();
 314
 315   tet_infoline("Test KeyEvents propagation. If DISPATCH_KEY_EVENTS property is false, the KeyEvent is also not received.");
 316
 317   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 318   DALI_TEST_CHECK(manager);
 319
 320   DummyControl dummy1 = DummyControl::New(true);
 321   dummy1.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 322   KeyEventCallback callback1( false );
 323   dummy1.KeyEventSignal().Connect( &callback1, &KeyEventCallback::Callback );
 324   stage.Add( dummy1 );
 325
 326   DummyControl dummy2 = DummyControl::New(true);
 327   dummy2.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 328   KeyEventCallback callback2( false );
 329   dummy2.KeyEventSignal().Connect( &callback2, &KeyEventCallback::Callback );
 330   // dummy2 set DISPATCH_KEY_EVENTS property to false.
 331   dummy2.SetProperty( Toolkit::DevelControl::Property::DISPATCH_KEY_EVENTS, false);
 332   dummy1.Add( dummy2 );
 333
 334   DummyControl dummy3 = DummyControl::New(true);
 335   Impl::DummyControl& dummy3Impl = static_cast<Impl::DummyControl&>(dummy3.GetImplementation());
 336   dummy3.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 337   KeyEventCallback callback3( false );
 338   dummy3.KeyEventSignal().Connect( &callback3, &KeyEventCallback::Callback );
 339   dummy2.Add( dummy3 );
 340   DALI_TEST_CHECK( ! dummy3Impl.keyInputFocusGained );
 341   DALI_TEST_CHECK( ! dummy3Impl.keyInputFocusLost );
 342
 343   manager.SetFocus( dummy3 );
 344   DALI_TEST_CHECK( dummy3Impl.keyInputFocusGained );
 345
 346   Integration::KeyEvent event( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "", "", Device::Class::TOUCH, Device::Subclass::NONE );
 347   application.ProcessEvent(event);
 348
 349   DALI_TEST_CHECK( !callback1.mIsCalled );
 350   DALI_TEST_CHECK( !callback2.mIsCalled );
 351   DALI_TEST_CHECK( !callback3.mIsCalled );
 352
 353   END_TEST;
 354 }
 355
 356 int UtcDaliKeyInputFocusManagerGetCurrentFocusControl(void)
 357 {
 358   ToolkitTestApplication application;
 359   Integration::Scene stage = application.GetScene();
 360
 361   tet_infoline(" Add 2 controls, check they each get focused. Re-focus the first control - ensure it's now got focus (check signals)");
 362
 363   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 364   DALI_TEST_CHECK(manager);
 365
 366   DummyControl dummy1 = DummyControl::New(true);
 367   Impl::DummyControl& dummy1Impl = static_cast<Impl::DummyControl&>(dummy1.GetImplementation());
 368   dummy1.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 369   stage.Add( dummy1 );
 370   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusGained );
 371   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusLost );
 372
 373   DummyControl dummy2 = DummyControl::New(true);
 374   Impl::DummyControl& dummy2Impl = static_cast<Impl::DummyControl&>(dummy2.GetImplementation());
 375   dummy2.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 376   stage.Add( dummy2 );
 377   DALI_TEST_CHECK( ! dummy2Impl.keyInputFocusGained );
 378   DALI_TEST_CHECK( ! dummy2Impl.keyInputFocusLost );
 379
 380   manager.SetFocus(dummy1);
 381   DALI_TEST_CHECK( dummy1 == manager.GetCurrentFocusControl() );
 382   DALI_TEST_CHECK( dummy1Impl.keyInputFocusGained );
 383   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusLost );
 384   dummy1Impl.keyInputFocusGained = false;
 385   dummy1Impl.keyInputFocusLost = false;
 386
 387   manager.SetFocus(dummy2);
 388   DALI_TEST_CHECK( dummy2 == manager.GetCurrentFocusControl() );
 389   DALI_TEST_CHECK( dummy1Impl.keyInputFocusLost );
 390   DALI_TEST_CHECK( dummy2Impl.keyInputFocusGained );
 391   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusGained );
 392   DALI_TEST_CHECK( ! dummy2Impl.keyInputFocusLost );
 393   // Reset signal received
 394   dummy1Impl.keyInputFocusGained = false;
 395   dummy1Impl.keyInputFocusLost = false;
 396   dummy2Impl.keyInputFocusGained = false;
 397   dummy2Impl.keyInputFocusLost = false;
 398
 399   manager.SetFocus(dummy1);
 400   DALI_TEST_CHECK( dummy1 == manager.GetCurrentFocusControl());
 401   DALI_TEST_CHECK( dummy1Impl.keyInputFocusGained );
 402   DALI_TEST_CHECK( dummy2Impl.keyInputFocusLost );
 403   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusLost );
 404   DALI_TEST_CHECK( ! dummy2Impl.keyInputFocusGained );
 405   END_TEST;
 406 }
 407
 408 int UtcDaliKeyInputFocusManagerRemoveFocus(void)
 409 {
 410   ToolkitTestApplication application;
 411   Integration::Scene stage = application.GetScene();
 412
 413   tet_infoline(" Add focus controls. Test that removing focus from control which has focus. ");
 414
 415   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 416   DALI_TEST_CHECK(manager);
 417
 418   DummyControl dummy1 = DummyControl::New(true);
 419   Impl::DummyControl& dummy1Impl = static_cast<Impl::DummyControl&>(dummy1.GetImplementation());
 420   dummy1.SetProperty( Actor::Property::SIZE, Vector2(100.0f, 100.0f) );
 421   stage.Add( dummy1 );
 422   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusGained );
 423   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusLost );
 424
 425   manager.SetFocus(dummy1);
 426   DALI_TEST_CHECK(dummy1 == manager.GetCurrentFocusControl());
 427   dummy1Impl.keyInputFocusGained = false;
 428   dummy1Impl.keyInputFocusLost = false;
 429
 430   manager.RemoveFocus(dummy1);
 431   DALI_TEST_CHECK(Control() == manager.GetCurrentFocusControl());
 432   DALI_TEST_CHECK( dummy1Impl.keyInputFocusLost );
 433   DALI_TEST_CHECK( ! dummy1Impl.keyInputFocusGained );
 434
 435   END_TEST;
 436 }
 437
 438 int UtcDaliKeyInputFocusManagerSignalKeyInputFocusChanged(void)
 439 {
 440   ToolkitTestApplication application;
 441   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 442   Integration::Scene stage = application.GetScene();
 443
 444   tet_infoline(" UtcDaliKeyInputFocusManagerSignalKeyInputFocusChanged");
 445
 446   PushButton pushButton1 = PushButton::New();
 447   PushButton pushButton2 = PushButton::New();
 448
 449   stage.Add( pushButton1 );
 450   stage.Add( pushButton2 );
 451
 452   PushButton gainActor, lostActor;
 453   KeyInputFocusChangedCallback callback( gainActor, lostActor );
 454   manager.KeyInputFocusChangedSignal().Connect( &callback, &KeyInputFocusChangedCallback::Callback );
 455
 456   manager.SetFocus(pushButton1);
 457
 458   DALI_TEST_CHECK( gainActor == pushButton1 );
 459   DALI_TEST_CHECK( lostActor == Control() );
 460
 461   gainActor.Reset();
 462   lostActor.Reset();
 463
 464   manager.SetFocus(pushButton2);
 465
 466   DALI_TEST_CHECK( gainActor == pushButton2 );
 467   DALI_TEST_CHECK( lostActor == pushButton1 );
 468
 469   gainActor.Reset();
 470   lostActor.Reset();
 471
 472   // Removing the focus actor from the stage would also result in signal emission.
 473   stage.Remove( pushButton1 );
 474   stage.Remove( pushButton2 );
 475
 476   DALI_TEST_CHECK( gainActor == Control() );
 477   DALI_TEST_CHECK( lostActor == Control() );
 478   END_TEST;
 479 }
 480
 481 int UtcDaliKeyInputFocusManagerSignalKeyInputFocusChangedforNewWindow(void)
 482 {
 483   ToolkitTestApplication application;
 484   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 485
 486   tet_infoline(" UtcDaliKeyInputFocusManagerSignalKeyInputFocusChanged");
 487
 488   PushButton pushButton1 = PushButton::New();
 489   PushButton pushButton2 = PushButton::New();
 490
 491   Window window = Window::New(PositionSize(0,0,0,0) ,"", false);
 492   DALI_TEST_CHECK( window );
 493
 494   window.Add( pushButton1 );
 495   window.Add( pushButton2 );
 496
 497   PushButton gainActor, lostActor;
 498   KeyInputFocusChangedCallback callback( gainActor, lostActor );
 499   manager.KeyInputFocusChangedSignal().Connect( &callback, &KeyInputFocusChangedCallback::Callback );
 500
 501   manager.SetFocus(pushButton1);
 502
 503   DALI_TEST_CHECK( gainActor == pushButton1 );
 504   DALI_TEST_CHECK( lostActor == Control() );
 505
 506   gainActor.Reset();
 507   lostActor.Reset();
 508
 509   manager.SetFocus(pushButton2);
 510
 511   DALI_TEST_CHECK( gainActor == pushButton2 );
 512   DALI_TEST_CHECK( lostActor == pushButton1 );
 513
 514   gainActor.Reset();
 515   lostActor.Reset();
 516
 517   // Removing the focus actor from the window would also result in signal emission.
 518   window.Remove( pushButton1 );
 519   window.Remove( pushButton2 );
 520   DALI_TEST_CHECK( gainActor == Control() );
 521   DALI_TEST_CHECK( lostActor == Control() );
 522
 523   window.Reset();
 524   END_TEST;
 525 }