Dali 3D User Interface Engine
signal-helper.h
Go to the documentation of this file.
1 #ifndef SIGNAL_HELPER
2 #define SIGNAL_HELPER
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 // Helper classes for testing DALi signal and slots
22 
24 {
25 public:
26 
27  TestButton( unsigned int id )
28  : mId(id)
29  {
30  }
31 
32  void Press()
33  {
34  mPanelDown.Emit( *this );
35  }
36 
37  void Release()
38  {
39  mPanelUp.Emit( *this );
40  }
41 
42  typedef Signal< void (TestButton&) > PanelDownSignal;
43  typedef Signal< void (TestButton&) > PanelUpSignal;
44 
46  {
47  return mPanelDown;
48  }
49 
51  {
52  return mPanelUp;
53  }
54 
55  int GetId()
56  {
57  return mId;
58  }
59 
60 private:
61 
62  int mId;
65 };
66 
67 class TestApp : public ConnectionTracker
68 {
69 public:
70 
72  : mButtonPressed( false ),
73  mVoidFunctionCalled( false )
74  {
75  }
76 
77  void OnButtonPress( TestButton& button )
78  {
79  mButtonPressed = true;
80  mButtonId = button.GetId();
81  }
82 
83  void OnButtonRelease( TestButton& button )
84  {
85  mButtonPressed = false;
86  mButtonId = button.GetId();
87  }
88 
90  {
91  return mButtonId;
92  }
93 
95  {
96  return false;
97  }
98 
100  {
101  return true;
102  }
103 
105  {
106  mVoidFunctionCalled = true;
107  }
108 
112 };
113 
115 {
116 public:
117 
118  // Void return, no parameters
119  typedef Signal<void ()> VoidRetNoParamSignal;
120 
121  // Void return, 1 value parameter
122  typedef Signal<void (int)> VoidRet1ValueParamSignal;
123 
124  // Void return, 1 reference parameter
125  typedef Signal< void (int&)> VoidRet1RefParamSignal;
126 
127  // Void return, 2 value parameters
128  typedef Signal<void (int, int)> VoidRet2ValueParamSignal;
129 
130  // Void return, 3 value parameters
131  typedef Signal<void (int, int, int)> VoidRet3ValueParamSignal;
132 
133  // bool return, 1 value parameter
134  typedef Signal< bool (float)> BoolRet1ValueParamSignal;
135 
136  // bool return, 2 value parameter
137  typedef Signal<bool (float, int) > BoolRet2ValueParamSignal;
138 
139  // int return, 2 value parameter
140  typedef Signal<int (float, int)> IntRet2ValueParamSignal;
141 
142  // float return, 0 parameters
143  typedef Signal< float () > FloatRet0ParamSignal;
144 
145  // float return, 1 value parameters
146  typedef Signal< float (float ) > FloatRet1ParamSignal;
147 
148  // float return, 2 value parameters
149  typedef Signal<float (float, float) > FloatRet2ValueParamSignal;
150 
151  // float return, 3 value parameters
152  typedef Signal<float (float, float, float) > FloatRet3ValueParamSignal;
153 
154  // void return, 3 value parameters
155  typedef Signal<void (float, float, float) > VoidSignalTypeFloatValue3;
156 
157 
163 
170 
173 
175  {
176  }
177 
179  {
180  DALI_TEST_EQUALS( mSignalVoid0.GetConnectionCount(), 0u, TEST_LOCATION );
181  DALI_TEST_EQUALS( mSignalVoid1R.GetConnectionCount(), 0u, TEST_LOCATION );
182  DALI_TEST_EQUALS( mSignalVoid1V.GetConnectionCount(), 0u, TEST_LOCATION );
183  DALI_TEST_EQUALS( mSignalVoid2V.GetConnectionCount(), 0u, TEST_LOCATION );
184  DALI_TEST_EQUALS( mSignalVoid3V.GetConnectionCount(), 0u, TEST_LOCATION );
185  DALI_TEST_EQUALS( mSignalBool1V.GetConnectionCount(), 0u, TEST_LOCATION );
186  DALI_TEST_EQUALS( mSignalBool2V.GetConnectionCount(), 0u, TEST_LOCATION );
187  DALI_TEST_EQUALS( mSignalInt2V.GetConnectionCount(), 0u, TEST_LOCATION );
188  DALI_TEST_EQUALS( mSignalFloat0.GetConnectionCount(), 0u, TEST_LOCATION );
189  DALI_TEST_EQUALS( mSignalFloat1V.GetConnectionCount(), 0u, TEST_LOCATION );
190  DALI_TEST_EQUALS( mSignalFloat2V.GetConnectionCount(), 0u, TEST_LOCATION );
191  DALI_TEST_EQUALS( mVoidSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
192  DALI_TEST_EQUALS( mFloatSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
193  }
194 
196  {
197  mSignalVoid0.Emit();
198  }
199 
200  void EmitVoidSignalIntRef(int& ref)
201  {
202  mSignalVoid1R.Emit(ref);
203  }
204 
206  {
207  mSignalVoid1V.Emit(p1);
208  }
209 
210  void EmitVoidSignal2IntValue(int p1, int p2)
211  {
212  mSignalVoid2V.Emit(p1,p2);
213  }
214 
215  void EmitVoidSignal3IntValue(int p1, int p2, int p3)
216  {
217  mSignalVoid3V.Emit(p1,p2,p3);
218  }
219 
220 
222  {
223  return mSignalBool1V.Emit(p1);
224  }
225 
227  {
228  return mSignalBool2V.Emit(p1, p2);
229  }
230 
232  {
233  return mSignalInt2V.Emit(p1, p2);
234  }
235 
236  float EmitFloat1VSignal(float p1 )
237  {
238  return mSignalFloat1V.Emit(p1 );
239  }
240 
241  float EmitFloat2VSignal(float p1, float p2)
242  {
243  return mSignalFloat2V.Emit(p1, p2);
244  }
245 
247  {
248  return mSignalFloat0.Emit();
249  }
250 
251  void EmitVoidSignalFloatValue3(float p1, float p2, float p3)
252  {
253  mVoidSignalFloatValue3.Emit(p1, p2, p3);
254  }
255 
256  float EmitFloat3VSignal(float p1, float p2, float p3)
257  {
258  return mFloatSignalFloatValue3.Emit(p1, p2, p3);
259  }
260 
261 private:
262 
268 
277 };
278 
282 class TestSlotHandler : public ConnectionTracker
283 {
284 public:
285 
287  : mIntParam1( 0 ),
288  mIntParam2( 0 ),
289  mIntParam3( 0 ),
290  mFloatParam1( 0.0f ),
291  mFloatParam2( 0.0f ),
292  mFloatParam3( 0.0f ),
293  mBoolReturn( false ),
294  mIntReturn( 0 ),
295  mFloatReturn( 0.0f ),
296  mHandled( false ),
297  mHandledCount( 0 )
298  {
299  }
300 
301  void Reset()
302  {
303  mIntParam1 = 0;
304  mIntParam2 = 0;
305  mIntParam3 = 0;
306  mFloatParam1 = 0.0f;
307  mFloatParam2 = 0.0f;
308  mFloatParam3 = 0.0f;
309  mBoolReturn = false;
310  mIntReturn = 0;
311  mFloatReturn = 0.0f;
312  mHandled = false;
313  }
314 
316  {
317  mHandled = true;
318  ++mHandledCount;
319  }
320 
322  {
323  mHandled = true;
324  ++mHandledCount;
325  }
326 
327  void VoidSlotIntRef( int& p1 )
328  {
329  mIntParam1 = p1;
330  mHandled = true;
331  ++mHandledCount;
332  }
333 
334  void VoidSlotIntValue( int p1 )
335  {
336  mIntParam1 = p1;
337  mHandled = true;
338  ++mHandledCount;
339  }
340 
342  {
343  mIntParam2 = p1;
344  mHandled = true;
345  ++mHandledCount;
346  }
347 
348  void VoidSlotIntValueIntValue( int p1, int p2 )
349  {
350  mIntParam1 = p1;
351  mIntParam2 = p2;
352  mHandled = true;
353  ++mHandledCount;
354  }
355 
356  bool BoolSlotFloatValue( float p1 )
357  {
358  mFloatParam1 = p1;
359  mHandled = true;
360  ++mHandledCount;
361  return mBoolReturn;
362  }
363 
364  bool BoolSlotFloatValueIntValue( float p1, int p2 )
365  {
366  mFloatParam1 = p1;
367  mIntParam2 = p2;
368  mHandled = true;
369  ++mHandledCount;
370  return mBoolReturn;
371  }
372 
373  int IntSlotFloatValueIntValue( float p1, int p2 )
374  {
375  mFloatParam1 = p1;
376  mIntParam2 = p2;
377  mHandled = true;
378  ++mHandledCount;
379  return mIntReturn;
380  }
381 
383  {
384  mHandled = true;
385  ++mHandledCount;
386  return mFloatReturn;
387  }
388 
389  float FloatSlotFloatValueFloatValue( float p1, float p2 )
390  {
391  mFloatParam1 = p1;
392  mFloatParam2 = p2;
393  mHandled = true;
394  ++mHandledCount;
395  return mFloatReturn;
396  }
397 
398  void VoidSlotFloatValue3( float p1, float p2, float p3 )
399  {
400  mFloatParam1 = p1;
401  mFloatParam2 = p2;
402  mFloatParam3 = p3;
403  mHandled = true;
404  ++mHandledCount;
405  }
406 
407  float FloatSlotFloatValue3( float p1, float p2, float p3 )
408  {
409  mFloatParam1 = p1;
410  mFloatParam2 = p2;
411  mFloatParam3 = p3;
412  mHandled = true;
413  ++mHandledCount;
414  return mFloatReturn;
415  }
416 
422  bool mHandled;
424 };
425 
429 class TestSlotDisconnector : public ConnectionTracker
430 {
431 public:
432 
434  : mIntParam1( 0 ),
435  mIntParam2( 0 ),
436  mIntParam3( 0 ),
437  mFloatParam1( 0.0f ),
438  mFloatParam2( 0.0f ),
439  mBoolReturn( false ),
440  mIntReturn( 0 ),
441  mFloatReturn( 0.0f ),
442  mHandled( false )
443  {
444  }
445 
446  void Reset()
447  {
448  mIntParam1 = 0;
449  mIntParam2 = 0;
450  mIntParam3 = 0;
451  mFloatParam1 = 0.0f;
452  mFloatParam2 = 0.0f;
453  mBoolReturn = false;
454  mIntReturn = 0;
455  mFloatReturn = 0.0f;
456  mHandled = false;
457  }
458 
460  {
461  mVoidSignalVoid = &signal;
462  signal.Connect( this, &TestSlotDisconnector::VoidSlotVoid );
463  }
464 
466  {
468  mHandled = true;
469  }
470 
472  {
473  mVoidSignalIntRef = &signal;
474  signal.Connect( this, &TestSlotDisconnector::VoidSlotIntRef );
475  }
476 
477  void VoidSlotIntRef( int& p1 )
478  {
480  mIntParam1 = p1;
481  mHandled = true;
482  }
483 
484  void VoidSlotIntValue( int p1 )
485  {
486  mIntParam1 = p1;
487  mHandled = true;
488  }
489 
490  void VoidSlotIntValueIntValue( int p1, int p2 )
491  {
492  mIntParam1 = p1;
493  mIntParam2 = p2;
494  mHandled = true;
495  }
496 
497  bool BoolSlotFloatValue( float p1 )
498  {
499  mFloatParam1 = p1;
500  mHandled = true;
501  return mBoolReturn;
502  }
503 
504  bool BoolSlotFloatValueIntValue( float p1, int p2 )
505  {
506  mFloatParam1 = p1;
507  mIntParam2 = p2;
508  mHandled = true;
509  return mBoolReturn;
510  }
511 
512  int IntSlotFloatValueIntValue( float p1, int p2 )
513  {
514  mFloatParam1 = p1;
515  mIntParam2 = p2;
516  mHandled = true;
517  return mIntReturn;
518  }
519 
521  {
522  mHandled = true;
523  return mFloatReturn;
524  }
525 
526  float FloatSlotFloatValueFloatValue( float p1, float p2 )
527  {
528  mFloatParam1 = p1;
529  mFloatParam2 = p2;
530  mHandled = true;
531  return mFloatReturn;
532  }
533 
536 
542  bool mHandled;
543 };
544 
548 class TestSlotMultiDisconnector : public ConnectionTracker
549 {
550 public:
551 
552  static const int NUM_SLOTS = 10;
553 
555  : mVoidSignalVoid( NULL )
556  {
557  Reset();
558  }
559 
560  void Reset()
561  {
562  for( int i=0; i<NUM_SLOTS; ++i )
563  {
564  mSlotHandled[i] = false;
565  }
566  }
567 
569  {
570  mVoidSignalVoid = &signal;
571  signal.Connect( this, &TestSlotMultiDisconnector::Slot0 );
572  signal.Connect( this, &TestSlotMultiDisconnector::Slot1 );
573  signal.Connect( this, &TestSlotMultiDisconnector::Slot2 );
574  signal.Connect( this, &TestSlotMultiDisconnector::Slot3 );
575  signal.Connect( this, &TestSlotMultiDisconnector::Slot4 );
576  signal.Connect( this, &TestSlotMultiDisconnector::Slot5 );
577  signal.Connect( this, &TestSlotMultiDisconnector::Slot6 );
578  signal.Connect( this, &TestSlotMultiDisconnector::Slot7 );
579  signal.Connect( this, &TestSlotMultiDisconnector::Slot8 );
580  signal.Connect( this, &TestSlotMultiDisconnector::Slot9 );
581  }
582 
583  void Slot0()
584  {
585  mSlotHandled[0] = true;
586  }
587 
588  void Slot1()
589  {
590  mSlotHandled[1] = true;
591  }
592 
593  void Slot2()
594  {
595  mSlotHandled[2] = true;
596  }
597 
598  void Slot3()
599  {
600  mSlotHandled[3] = true;
601 
602  // Disconnect the odd numbered lots, because we can
608  }
609 
610  void Slot4()
611  {
612  mSlotHandled[4] = true;
613  }
614 
615  void Slot5()
616  {
617  mSlotHandled[5] = true;
618  }
619 
620  void Slot6()
621  {
622  mSlotHandled[6] = true;
623  }
624 
625  void Slot7()
626  {
627  mSlotHandled[7] = true;
628  }
629 
630  void Slot8()
631  {
632  mSlotHandled[8] = true;
633  }
634 
635  void Slot9()
636  {
637  mSlotHandled[9] = true;
638  }
639 
641 
643 };
644 
645 
649 class TestEmitDuringCallback : public ConnectionTracker
650 {
651 public:
652 
654  : mVoidSignalVoid( NULL ),
655  mFloatRet0ParamSignal( NULL),
656  mFloatRet1ParamSignal( NULL ),
657  mFloatRet2ParamSignal( NULL ),
658  mFloatRet3ParamSignal( NULL ),
659  mHandled( false )
660  {
661  }
662 
664  {
665  mVoidSignalVoid = &signal;
666  signal.Connect( this, &TestEmitDuringCallback::VoidSlotVoid );
667  }
668 
670  {
671  mFloatRet0ParamSignal = &signal;
672  signal.Connect( this, &TestEmitDuringCallback::FloatRet0Param );
673  }
675  {
676  mFloatRet1ParamSignal = &signal;
677  signal.Connect( this, &TestEmitDuringCallback::FloatRet1Param );
678  }
680  {
681  mFloatRet2ParamSignal = &signal;
682  signal.Connect( this, &TestEmitDuringCallback::FloatRet2Param );
683  }
685  {
686  mFloatRet3ParamSignal = &signal;
687  signal.Connect( this, &TestEmitDuringCallback::FloatRet3Param );
688  }
689 
691  {
692  mVoidSignalVoid = &signal;
693  signal.Connect( this, &TestEmitDuringCallback::DeleteSignalDuringEmit );
694  }
695 
697  {
698  // Emitting during Emit is very bad!
699  mVoidSignalVoid->Emit();
700  mHandled = true;
701  }
702 
704  {
705  // deleting the signal during the emit
706  delete mVoidSignalVoid;
707  }
708 
710  {
711  // Emitting during Emit is very bad!
712  mHandled = true;
713  return mFloatRet0ParamSignal->Emit();
714  }
715  float FloatRet1Param( float x )
716  {
717  // Emitting during Emit is very bad!
718  mHandled = true;
719  return mFloatRet1ParamSignal->Emit(x);
720  }
721  float FloatRet2Param( float x, float y )
722  {
723  // Emitting during Emit is very bad!
724  mHandled = true;
725  return mFloatRet2ParamSignal->Emit( x, y );
726  }
727  float FloatRet3Param( float x, float y, float z)
728  {
729  // Emitting during Emit is very bad!
730  mHandled = true;
731  return mFloatRet3ParamSignal->Emit( x, y, z );
732  }
733 
739 
740 
741  bool mHandled;
742 };
743 
744 
748 class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
749 {
750 public:
751 
753  : mSlotDelegate( this ),
754  mIntParam1( 0 ),
755  mIntParam2( 0 ),
756  mIntParam3( 0 ),
757  mFloatParam1( 0.0f ),
758  mFloatParam2( 0.0f ),
759  mFloatParam3( 0.0f ),
760  mBoolReturn( false ),
761  mIntReturn( 0 ),
762  mFloatReturn( 0.0f ),
763  mHandled( false ),
764  mHandledCount( 0 )
765  {
766  }
767 
768  void Reset()
769  {
770  mIntParam1 = 0;
771  mIntParam2 = 0;
772  mIntParam3 = 0;
773  mFloatParam1 = 0.0f;
774  mFloatParam2 = 0.0f;
775  mFloatParam3 = 0.0f;
776  mBoolReturn = false;
777  mIntReturn = 0;
778  mFloatReturn = 0.0f;
779  mHandled = false;
780  }
781 
783  {
784  mHandled = true;
785  ++mHandledCount;
786  }
787 
789  {
790  mHandled = true;
791  ++mHandledCount;
792  }
793 
794  void VoidSlotIntRef( int& p1 )
795  {
796  mIntParam1 = p1;
797  mHandled = true;
798  ++mHandledCount;
799  }
800 
801  void VoidSlotIntValue( int p1 )
802  {
803  mIntParam1 = p1;
804  mHandled = true;
805  ++mHandledCount;
806  }
807 
809  {
810  mIntParam2 = p1;
811  mHandled = true;
812  ++mHandledCount;
813  }
814 
815  void VoidSlotIntValueIntValue( int p1, int p2 )
816  {
817  mIntParam1 = p1;
818  mIntParam2 = p2;
819  mHandled = true;
820  ++mHandledCount;
821  }
822 
823  bool BoolSlotFloatValue( float p1 )
824  {
825  mFloatParam1 = p1;
826  mHandled = true;
827  ++mHandledCount;
828  return mBoolReturn;
829  }
830 
831  bool BoolSlotFloatValueIntValue( float p1, int p2 )
832  {
833  mFloatParam1 = p1;
834  mIntParam2 = p2;
835  mHandled = true;
836  ++mHandledCount;
837  return mBoolReturn;
838  }
839 
840  int IntSlotFloatValueIntValue( float p1, int p2 )
841  {
842  mFloatParam1 = p1;
843  mIntParam2 = p2;
844  mHandled = true;
845  ++mHandledCount;
846  return mIntReturn;
847  }
848 
850  {
851  mHandled = true;
852  ++mHandledCount;
853  return mFloatReturn;
854  }
855 
856  float FloatSlotFloatValueFloatValue( float p1, float p2 )
857  {
858  mFloatParam1 = p1;
859  mFloatParam2 = p2;
860  mHandled = true;
861  ++mHandledCount;
862  return mFloatReturn;
863  }
864 
865  void VoidSlotFloatValue3( float p1, float p2, float p3 )
866  {
867  mFloatParam1 = p1;
868  mFloatParam2 = p2;
869  mFloatParam3 = p3;
870  mHandled = true;
871  ++mHandledCount;
872  }
873 
874  float FloatSlotFloatValue3( float p1, float p2, float p3 )
875  {
876  mFloatParam1 = p1;
877  mFloatParam2 = p2;
878  mFloatParam3 = p3;
879  mHandled = true;
880  ++mHandledCount;
881  return mFloatReturn;
882  }
883 
884  SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
885 
891  bool mHandled;
893 };
894 
899 class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
900 {
901 public:
902 
904  : mCallbackHandled( false ),
905  mCallback( NULL ),
906  mSlotObserver( NULL )
907  {
908  }
909 
911  {
912  if( mSlotObserver && mCallback )
913  {
914  // Notify signal since the slot has been destroyed
915  mSlotObserver->SlotDisconnected( mCallback );
916  // mCallback and mSlotObserver are not owned
917  }
918  }
919 
924  {
925  mCallbackHandled = true;
926  }
927 
931  virtual std::size_t GetConnectionCount() const
932  {
933  if( mCallback )
934  {
935  return 1u;
936  }
937 
938  return 0u;
939  }
940 
944  virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
945  {
946  DALI_ASSERT_ALWAYS( NULL == mCallback && "Only one connection supported!" );
947 
948  mCallback = callback;
949  mSlotObserver = slotObserver;
950  }
951 
955  virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
956  {
957  if( mSlotObserver == slotObserver )
958  {
959  mSlotObserver = NULL;
960  mCallback = NULL;
961  // mCallback and mSlotObserver are not owned
962  }
963  }
964 
970  {
971  mSlotObserver->SlotDisconnected( NULL );
972  }
973 
974 private:
975 
978 
979 public:
980 
982 
983 private:
984 
985  CallbackBase* mCallback;
986  SlotObserver* mSlotObserver;
987 };
988 
989 
990 
991 
992 // for testing static function callbacks
994 {
995 public:
997  {
998  staticFunctionHandled = false;
999  }
1000  void Reset()
1001  {
1002  staticFunctionHandled = false;
1003  }
1004 
1005  static void VoidSlotVoid()
1006  {
1007  staticFunctionHandled = true;
1008  }
1009  static void VoidSlot1Param( int p1 )
1010  {
1011  staticFunctionHandled = true;
1012  }
1013  static void VoidSlot2Param( int p1, int p2 )
1014  {
1015  staticFunctionHandled = true;
1016  }
1017  static void VoidSlot3Param( int p1, int p2, int p3 )
1018  {
1019  staticFunctionHandled = true;
1020  }
1021 
1022  static float RetSlot0Param( )
1023  {
1024  staticFunctionHandled = true;
1025  return 0;
1026  }
1027  static float RetSlot1Param( float p1 )
1028  {
1029  staticFunctionHandled = true;
1030  return 0;
1031  }
1032  static float RetSlot2Param( float p1, float p2 )
1033  {
1034  staticFunctionHandled = true;
1035  return 0;
1036  }
1037  static float RetSlot3Param( float p1, float p2, float p3 )
1038  {
1039  staticFunctionHandled = true;
1040  return 0;
1041  }
1042 
1044 };
1045 
1046 
1052 {
1053  TestFunctor( bool& functorCalled):
1054  mFunctorCalled( functorCalled )
1055  {
1056  };
1057 
1058  void operator()()
1059  {
1060  mFunctorCalled = true;
1061  }
1062 
1064 };
1065 
1067 {
1068  VoidFunctorVoid( bool& functorCalled):
1069  mFunctorCalled( functorCalled )
1070  {
1071 
1072  }
1073 
1074  void operator()()
1075  {
1076  mFunctorCalled = true;
1077  }
1078 
1080 };
1081 
1082 #endif // #define SIGNAL_HELPER
Dali Docs Home
Read more about Dali