Dali 3D User Interface Engine
utc-Dali-KeyboardFocusManager.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 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 
21 // Need to override adaptor classes for toolkit test harness, so include
22 // test harness headers before dali headers.
24 
27 
28 
29 using namespace Dali;
30 using namespace Dali::Toolkit;
31 
33 {
35 }
36 
38 {
40 }
41 
42 
43 namespace
44 {
45 
46 // Functors to test whether PreFocusChange signal is emitted when the keyboard focus is about to change
48 {
49 public:
50  PreFocusChangeCallback(bool& signalReceived)
51  : mSignalVerified(signalReceived),
52  mCurrentFocusedActor(),
53  mProposedActorToFocus(),
54  mDirection(Control::KeyboardFocus::LEFT)
55  {
56  }
57 
58  Actor Callback(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocus::Direction direction)
59  {
60  tet_infoline("Verifying PreFocusChangeCallback()");
61 
62  mSignalVerified = true;
63 
64  mCurrentFocusedActor = currentFocusedActor;
65  mProposedActorToFocus = proposedActorToFocus;
66  mDirection = direction;
67 
68  return mProposedActorToFocus;
69  }
70 
71  void Reset()
72  {
73  mSignalVerified = false;
74  mCurrentFocusedActor = Actor();
75  mProposedActorToFocus = Actor();
76  mDirection = Control::KeyboardFocus::LEFT;
77  }
78 
83 };
84 
85 // Functors to test whether focus changed signal is emitted when the keyboard focus is changed
87 {
88 public:
89  FocusChangedCallback(bool& signalReceived)
90  : mSignalVerified(signalReceived),
91  mOriginalFocusedActor(),
92  mCurrentFocusedActor()
93  {
94  }
95 
96  void Callback(Actor originalFocusedActor, Actor currentFocusedActor)
97  {
98  tet_infoline("Verifying FocusChangedCallback()");
99 
100  if(originalFocusedActor == mCurrentFocusedActor)
101  {
102  mSignalVerified = true;
103  }
104 
105  mOriginalFocusedActor = originalFocusedActor;
106  mCurrentFocusedActor = currentFocusedActor;
107  }
108 
109  void Reset()
110  {
111  mSignalVerified = false;
112  }
113 
117 };
118 
119 // Functors to test whether focus group changed signal is emitted when the keyboard focus group is changed
121 {
122 public:
123  FocusGroupChangedCallback(bool& signalReceived)
124  : mSignalVerified(signalReceived),
125  mCurrentFocusedActor(),
126  mForward(true)
127  {
128  }
129 
130  void Callback(Actor currentFocusedActor, bool forward)
131  {
132  tet_infoline("Verifying FocusGroupChangedCallback()");
133 
134  mSignalVerified = true;
135 
136  mCurrentFocusedActor = currentFocusedActor;
137  mForward = forward;
138  }
139 
140  void Reset()
141  {
142  mSignalVerified = false;
143  }
144 
147  bool mForward;
148 };
149 
150 // Functors to test whether focused actor activated signal is emitted when the focused actor is activated
152 {
153 public:
154  FocusedActorActivatedCallback(bool& signalReceived)
155  : mSignalVerified(signalReceived),
156  mActivatedActor()
157  {
158  }
159 
160  void Callback(Actor activatedActor)
161  {
162  tet_infoline("Verifying FocusedActorActivatedCallback()");
163 
164  mSignalVerified = true;
165 
166  mActivatedActor = activatedActor;
167  }
168 
169  void Reset()
170  {
171  mSignalVerified = false;
172  }
173 
176 };
177 
178 } // namespace
179 
180 
182 {
183  ToolkitTestApplication application;
184 
185  tet_infoline(" UtcDaliKeyboardKeyboardFocusManagerGet");
186 
187  // Register Type
188  TypeInfo type;
189  type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
190  DALI_TEST_CHECK( type );
191  BaseHandle handle = type.CreateInstance();
192  DALI_TEST_CHECK( handle );
193 
194  KeyboardFocusManager manager;
195 
196  manager = KeyboardFocusManager::Get();
197  DALI_TEST_CHECK(manager);
198 
200  DALI_TEST_CHECK(newManager);
201 
202  // Check that focus manager is a singleton
203  DALI_TEST_CHECK(manager == newManager);
204  END_TEST;
205 }
206 
208 {
209  ToolkitTestApplication application;
210 
211  tet_infoline(" UtcDaliKeyboardFocusManagerSetAndGetCurrentFocusActor");
212 
214  DALI_TEST_CHECK(manager);
215 
216  // Create the first actor and add it to the stage
217  Actor first = Actor::New();
218  first.SetKeyboardFocusable(true);
219  Stage::GetCurrent().Add(first);
220 
221  // Create the second actor and add it to the stage
222  Actor second = Actor::New();
223  second.SetKeyboardFocusable(true);
224  Stage::GetCurrent().Add(second);
225 
226  // Create the third actor but don't add it to the stage
227  Actor third = Actor::New();
228 
229  // Check that no actor is being focused yet.
231 
232  // Check that it will fail to set focus on an invalid actor
233  DALI_TEST_CHECK(manager.SetCurrentFocusActor(Actor()) == false);
234 
235  // Check that the focus is set on the first actor
236  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
237  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
238 
239  // Check that the focus is set on the second actor
240  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
241  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
242 
243  // Check that it will fail to set focus on the third actor as it's not in the stage
244  DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
245  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
246 
247  // Add the third actor to the stage
248  Stage::GetCurrent().Add(third);
249 
250  // Check that it will fail to set focus on the third actor as it's not focusable
251  DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
252  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
253 
254  // Make the third actor focusable
255  third.SetKeyboardFocusable(true);
256 
257  // Check that the focus is successfully moved to the third actor
258  DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
259  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
260  END_TEST;
261 }
262 
264 {
265  ToolkitTestApplication application;
266 
267  tet_infoline(" UtcDaliKeyboardFocusManagerMoveFocus");
268 
269  // Register Type
270  TypeInfo type;
271  type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
272  DALI_TEST_CHECK( type );
273  BaseHandle handle = type.CreateInstance();
274  DALI_TEST_CHECK( handle );
275 
277  DALI_TEST_CHECK(manager);
278 
279  bool preFocusChangeSignalVerified = false;
280  PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
281  manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
282 
283  bool focusChangedSignalVerified = false;
284  FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
285  manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
286 
287  // Create the first actor and add it to the stage
288  Actor first = Actor::New();
289  first.SetKeyboardFocusable(true);
290  Stage::GetCurrent().Add(first);
291 
292  // Create the second actor and add it to the stage
293  Actor second = Actor::New();
294  second.SetKeyboardFocusable(true);
295  Stage::GetCurrent().Add(second);
296 
297  // Move the focus to the right
299 
300  // Because no layout control in the stage and no actor is focused, it should emit the PreFocusChange signal
301  DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
302  DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
303  DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
304  DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
305  preFocusChangeCallback.Reset();
306 
307  // Check that the focus is set on the first actor
308  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
309  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
310  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
311  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
312  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
313  focusChangedCallback.Reset();
314 
315  // Move the focus towards right
317 
318  // Because no layout control in the stage and the first actor is focused, it should emit the PreFocusChange signal
319  DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
320  DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == first);
321  DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
322  DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
323  preFocusChangeCallback.Reset();
324 
325  // Check that the focus is set on the second actor
326  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
327  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
328  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
329  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
330  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
331  focusChangedCallback.Reset();
332 
333  // Move the focus towards up
334  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == false);
335 
336  // Because no layout control in the stage and no actor is focused, it should emit the PreFocusChange signal
337  DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
338  DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == second);
339  DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
340  DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::UP);
341  preFocusChangeCallback.Reset();
342  DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
343 
344  // Create a 2x2 table view and try to move focus inside it
345  TableView tableView = TableView::New( 2, 2 );
346  Stage::GetCurrent().Add(tableView);
347 
348  // Create the third actor
349  Actor third = Actor::New();
350  third.SetKeyboardFocusable(true);
351 
352  // Create the fourth actor
353  Actor fourth = Actor::New();
354  fourth.SetKeyboardFocusable(true);
355 
356  // Add the four children to table view
357  tableView.AddChild(first, TableView::CellPosition(0, 0));
358  tableView.AddChild(second, TableView::CellPosition(0, 1));
359  tableView.AddChild(third, TableView::CellPosition(1, 0));
360  tableView.AddChild(fourth, TableView::CellPosition(1, 1));
361 
362  // Set the focus to the first actor
363  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
364  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
365  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
366  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
367  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
368  focusChangedCallback.Reset();
369 
370  // Move the focus towards right
372  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
373  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
374  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
375  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
376  focusChangedCallback.Reset();
377 
378  // Move the focus towards down
379  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::DOWN) == true);
380  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == fourth);
381  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
382  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
383  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == fourth);
384  focusChangedCallback.Reset();
385 
386  // Move the focus towards left
388  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
389  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
390  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == fourth);
391  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == third);
392  focusChangedCallback.Reset();
393 
394  // Move the focus towards up
395  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == true);
396  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
397  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
398  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == third);
399  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
400  focusChangedCallback.Reset();
401 
402  // Move the focus towards left. The focus move will fail as no way to move it upwards
404  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
405  DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
406  DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == first);
407  DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
408  DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::LEFT);
409  preFocusChangeCallback.Reset();
410  DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
411 
412  // Enable the loop
413  manager.SetFocusGroupLoop(true);
414  DALI_TEST_CHECK(manager.GetFocusGroupLoop() == true);
415 
416  // Move the focus towards left again. The focus should move to the fourth actor.
418  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == fourth);
419  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
420  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
421  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == fourth);
422  focusChangedCallback.Reset();
423  END_TEST;
424 }
425 
427 {
428  ToolkitTestApplication application;
429 
430  tet_infoline(" UtcDaliKeyboardFocusManagerClearFocus");
431 
433  DALI_TEST_CHECK(manager);
434 
435  // Create the first actor and add it to the stage
436  Actor first = Actor::New();
437  first.SetKeyboardFocusable(true);
438  Stage::GetCurrent().Add(first);
439 
440  // Create the second actor and add it to the stage
441  Actor second = Actor::New();
442  second.SetKeyboardFocusable(true);
443  Stage::GetCurrent().Add(second);
444 
445  // Check that the focus is set on the first actor
446  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
447  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
448 
449  // Check that the focus is set on the second actor
450  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
451  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
452 
453  // Clear the focus
454  manager.ClearFocus();
455 
456  // Check that no actor is being focused now.
458  END_TEST;
459 }
460 
462 {
463  ToolkitTestApplication application;
464 
465  tet_infoline(" UtcDaliKeyboardFocusManagerSetAndGetFocusGroupLoop");
466 
468  DALI_TEST_CHECK(manager);
469 
470  // Check that the focus movement is not looped within the same focus group by default
471  DALI_TEST_CHECK(manager.GetFocusGroupLoop() == false);
472 
473  // Enable the loop
474  manager.SetFocusGroupLoop(true);
475  DALI_TEST_CHECK(manager.GetFocusGroupLoop() == true);
476  END_TEST;
477 }
478 
480 {
481  ToolkitTestApplication application;
482 
483  tet_infoline(" UtcDaliKeyboardFocusManagerSetAsFocusGroup");
484 
486  DALI_TEST_CHECK(manager);
487 
488  // Create an actor and check that it is not a focus group by default
489  Actor actor = Actor::New();
490  DALI_TEST_CHECK(manager.IsFocusGroup(actor) == false);
491 
492  // Set the actor as focus group
493  manager.SetAsFocusGroup(actor, true);
494 
495  // flush the queue and render once
496  application.SendNotification();
497  application.Render();
498 
499  DALI_TEST_CHECK(manager.IsFocusGroup(actor) == true);
500 
501  // Set the actor not as focus group
502  manager.SetAsFocusGroup(actor, false);
503 
504  // flush the queue and render once
505  application.SendNotification();
506  application.Render();
507 
508  DALI_TEST_CHECK(manager.IsFocusGroup(actor) == false);
509  END_TEST;
510 }
511 
513 {
514  ToolkitTestApplication application;
515 
516  tet_infoline(" UtcDaliKeyboardFocusManagerGetFocusGroup");
517 
519  DALI_TEST_CHECK(manager);
520 
521  // Create an actor with two child actors and add it to the stage
522  Actor parent = Actor::New();
523  Actor child = Actor::New();
524  parent.Add(child);
525  Stage::GetCurrent().Add(parent);
526 
527  // Create three actors and add them as the children of the first child actor
528  Actor grandChild = Actor::New();
529  child.Add(grandChild);
530 
531  // Set the parent and the first child actor as focus groups
532  manager.SetAsFocusGroup(parent, true);
533 
534  // flush the queue and render once
535  application.SendNotification();
536  application.Render();
537 
538  DALI_TEST_CHECK(manager.IsFocusGroup(parent) == true);
539 
540  // The current focus group should be the parent, As it is the immediate parent which is also a focus group.
541  DALI_TEST_CHECK(manager.GetFocusGroup(grandChild) == parent);
542 
543  manager.SetAsFocusGroup(child, true);
544 
545  // flush the queue and render once
546  application.SendNotification();
547  application.Render();
548 
549  DALI_TEST_CHECK(manager.IsFocusGroup(child) == true);
550 
551  // The focus group should be the child, As it is the immediate parent which is also a focus group.
552  DALI_TEST_CHECK(manager.GetFocusGroup(grandChild) == child);
553 
554  manager.SetAsFocusGroup(grandChild, true);
555 
556  // flush the queue and render once
557  application.SendNotification();
558  application.Render();
559 
560  DALI_TEST_CHECK(manager.IsFocusGroup(grandChild) == true);
561 
562  // The current focus group should be itself, As it is also a focus group.
563  DALI_TEST_CHECK(manager.GetFocusGroup(grandChild) == grandChild);
564  END_TEST;
565 }
566 
568 {
569  ToolkitTestApplication application;
570 
571  tet_infoline(" UtcDaliKeyboardFocusManagerSetAndGetFocusIndicator");
572 
574  DALI_TEST_CHECK(manager);
575 
576  Actor defaultFocusIndicatorActor = manager.GetFocusIndicatorActor();
577  DALI_TEST_CHECK(defaultFocusIndicatorActor);
578 
579  Actor newFocusIndicatorActor = Actor::New();
580  manager.SetFocusIndicatorActor(newFocusIndicatorActor);
581  DALI_TEST_CHECK(manager.GetFocusIndicatorActor() == newFocusIndicatorActor);
582  END_TEST;
583 }
584 
585 
587 {
588  ToolkitTestApplication application;
589 
590  tet_infoline(" UtcDaliKeyboardFocusManagerSignalFocusedActorActivated");
591 
593  DALI_TEST_CHECK(manager);
594 
595  bool focusedActorActivatedSignalVerified = false;
596  FocusedActorActivatedCallback focusedActorActivatedCallback(focusedActorActivatedSignalVerified);
597  manager.FocusedActorEnterKeySignal().Connect( &focusedActorActivatedCallback, &FocusedActorActivatedCallback::Callback );
598 
599  Integration::KeyEvent returnEvent("Return", "", 0, 0, 0, Integration::KeyEvent::Up);
600 
601  // Create the first button and add it to the stage
602  PushButton firstPushButton = PushButton::New();
603  firstPushButton.SetKeyboardFocusable(true);
604  Stage::GetCurrent().Add(firstPushButton);
605 
606  // Create the second button and add it to the stage
607  PushButton secondPushButton = PushButton::New();
608  secondPushButton.SetKeyboardFocusable(true);
609  Stage::GetCurrent().Add(secondPushButton);
610 
611  // Check that the focus is set on the first button
612  DALI_TEST_CHECK(manager.SetCurrentFocusActor(firstPushButton) == true);
613  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstPushButton);
614 
615  // Send the return event to activate the first button
616  application.ProcessEvent(returnEvent);
617  DALI_TEST_CHECK(focusedActorActivatedCallback.mSignalVerified);
618  DALI_TEST_CHECK(focusedActorActivatedCallback.mActivatedActor == firstPushButton);
619  focusedActorActivatedCallback.Reset();
620 
621  // Check that the focus is set on the second button
622  DALI_TEST_CHECK(manager.SetCurrentFocusActor(secondPushButton) == true);
623  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == secondPushButton);
624 
625  // Send the return event again to activate the second button
626  application.ProcessEvent(returnEvent);
627  DALI_TEST_CHECK(focusedActorActivatedCallback.mSignalVerified);
628  DALI_TEST_CHECK(focusedActorActivatedCallback.mActivatedActor == secondPushButton);
629  focusedActorActivatedCallback.Reset();
630  END_TEST;
631 }
632 
634 {
635  ToolkitTestApplication application;
636 
637  tet_infoline(" UtcDaliKeyboardFocusManagerSignalFocusGroupChanged");
638 
639  // Register Type
640  TypeInfo type;
641  type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
642  DALI_TEST_CHECK( type );
643  BaseHandle handle = type.CreateInstance();
644  DALI_TEST_CHECK( handle );
645 
647  DALI_TEST_CHECK(manager);
648 
649  bool focusGroupChangedSignalVerified = false;
650  FocusGroupChangedCallback focusGroupChangedCallback(focusGroupChangedSignalVerified);
651  manager.FocusGroupChangedSignal().Connect( &focusGroupChangedCallback, &FocusGroupChangedCallback::Callback );
652 
653  Integration::KeyEvent tabEvent("Tab", "", 0, 0, 0, Integration::KeyEvent::Down);
654  Integration::KeyEvent shiftTabEvent("Tab", "", 0, 1, 0, Integration::KeyEvent::Down);
655 
656  // Send the tab event to change focus group in the forward direction
657  application.ProcessEvent(tabEvent);
658  DALI_TEST_CHECK(focusGroupChangedCallback.mSignalVerified);
659  DALI_TEST_CHECK(focusGroupChangedCallback.mCurrentFocusedActor == Actor());
660  DALI_TEST_CHECK(focusGroupChangedCallback.mForward == true);
661  focusGroupChangedCallback.Reset();
662 
663  // Send the shift tab event to change focus group in the backward direction
664  application.ProcessEvent(shiftTabEvent);
665  DALI_TEST_CHECK(focusGroupChangedCallback.mSignalVerified);
666  DALI_TEST_CHECK(focusGroupChangedCallback.mCurrentFocusedActor == Actor());
667  DALI_TEST_CHECK(focusGroupChangedCallback.mForward == false);
668  focusGroupChangedCallback.Reset();
669  END_TEST;
670 }
Dali Docs Home
Read more about Dali