dali/internal/common/message.h

   1 #ifndef __DALI_INTERNAL_MESSAGE_H__
   2 #define __DALI_INTERNAL_MESSAGE_H__
   3
   4 /*
   5  * Copyright (c) 2014 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 // INTERNAL INCLUDES
  22 #include <dali/internal/common/buffer-index.h>
  23 #include <dali/internal/common/type-abstraction.h>
  24 #include <dali/internal/update/common/scene-graph-buffers.h>
  25
  26 namespace Dali
  27 {
  28
  29 namespace Internal
  30 {
  31
  32 /**
  33  * An abstract base class for messages queued across threads.
  34  * Messages are only allowed to contain value objects, either copies of the parameters or pointers
  35  * If message parameter type is & or const& the message will try to take a copy of the actual type
  36  */
  37 class MessageBase
  38 {
  39 public:
  40
  41   /**
  42    * Construct the message base.
  43    */
  44   MessageBase( )
  45   {
  46   }
  47
  48   /**
  49    * Virtual destructor
  50    */
  51   virtual ~MessageBase()
  52   {
  53   }
  54
  55   /**
  56    * Called to process the message.
  57    * @param [in] bufferIndex The current update/render buffer index (depending on which thread processes the message).
  58    */
  59   virtual void Process( BufferIndex bufferIndex ) = 0;
  60
  61 private:
  62 };
  63
  64 /**
  65  * Templated message which calls a member function of an object.
  66  * This allows nodes etc. to be modified in a thread-safe manner, when the update occurs in a separate thread.
  67  * The object lifetime must controlled i.e. not destroyed before the message is processed.
  68  */
  69 template< typename T >
  70 class Message : public MessageBase
  71 {
  72 public:
  73
  74   typedef void(T::*MemberFunction)();
  75
  76   /**
  77    * Create a message.
  78    * @note The object is expected to be const in the thread which sends this message.
  79    * However it can be modified when Process() is called in a different thread.
  80    * @param[in] obj The object to be updated in a separate thread.
  81    * @param[in] member The member function of the object.
  82    */
  83   Message( const T* obj, MemberFunction member )
  84   : MessageBase(),
  85     object( const_cast< T* >( obj ) ),
  86     memberFunction( member )
  87   {
  88   }
  89
  90   /**
  91    * Virtual destructor
  92    */
  93   virtual ~Message()
  94   {
  95   }
  96
  97   /**
  98    * @copydoc MessageBase::Process
  99    */
 100   virtual void Process( BufferIndex /*bufferIndex*/ )
 101   {
 102     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 103     (object->*memberFunction)();
 104   }
 105
 106 private:
 107
 108   T* object;
 109   MemberFunction memberFunction;
 110
 111 };
 112
 113 /**
 114  * Templated message which calls a member function of an object.
 115  * This overload passes one value-type parameter.
 116  * Template parameters need to match the MemberFunction!
 117  * The message will contain copy of the value (in case of & or const&)
 118  */
 119 template< typename T, typename P >
 120 class MessageValue1 : public MessageBase
 121 {
 122 public:
 123
 124   typedef void(T::*MemberFunction)( typename ParameterType< P >::PassingType );
 125
 126   /**
 127    * Create a message.
 128    * @note The object is expected to be const in the thread which sends this message.
 129    * However it can be modified when Process() is called in a different thread.
 130    * @param[in] obj The object.
 131    * @param[in] member The member function of the object.
 132    * @param[in] p1 The first value-type parameter to pass to the member function.
 133    */
 134   MessageValue1( const T* obj,
 135                  MemberFunction member,
 136                  typename ParameterType< P >::PassingType p1 )
 137   : MessageBase(),
 138     object( const_cast< T* >( obj ) ),
 139     memberFunction( member ),
 140     param1( p1 )
 141   {
 142   }
 143
 144   /**
 145    * Virtual destructor
 146    */
 147   virtual ~MessageValue1()
 148   {
 149   }
 150
 151   /**
 152    * @copydoc MessageBase::Process
 153    */
 154   virtual void Process( BufferIndex /*bufferIndex*/ )
 155   {
 156     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 157     (object->*memberFunction)( ParameterType< P >::PassObject( param1 ) );
 158   }
 159
 160 private:
 161
 162   T* object;
 163   MemberFunction memberFunction;
 164   typename ParameterType< P >::HolderType param1;
 165
 166 };
 167
 168 /**
 169  * Templated message which calls a member function of an object.
 170  * This overload passes two value-type parameters.
 171  * Template parameters need to match the MemberFunction!
 172  * The message will contain copy of the value (in case of & or const&)
 173  */
 174
 175 template< typename T, typename P1, typename P2 >
 176 class MessageValue2 : public MessageBase
 177 {
 178 public:
 179
 180   typedef void(T::*MemberFunction)(
 181       typename ParameterType< P1 >::PassingType,
 182       typename ParameterType< P2 >::PassingType );
 183
 184   /**
 185    * Create a message.
 186    * @note The object is expected to be const in the thread which sends this message.
 187    * However it can be modified when Process() is called in a different thread.
 188    * @param[in] obj The object.
 189    * @param[in] member The member function of the object.
 190    * @param[in] p1 The first parameter to pass to the member function.
 191    * @param[in] p2 The second parameter to pass to the member function.
 192    */
 193   MessageValue2( const T* obj,
 194                  MemberFunction member,
 195                  typename ParameterType< P1 >::PassingType p1,
 196                  typename ParameterType< P2 >::PassingType p2 )
 197   : MessageBase(),
 198     object( const_cast< T* >( obj ) ),
 199     memberFunction( member ),
 200     param1( p1 ),
 201     param2( p2 )
 202   {
 203   }
 204
 205   /**
 206    * Virtual destructor
 207    */
 208   virtual ~MessageValue2()
 209   {
 210   }
 211
 212   /**
 213    * @copydoc MessageBase::Process
 214    */
 215   virtual void Process( BufferIndex /*bufferIndex*/ )
 216   {
 217     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 218     (object->*memberFunction)(
 219         ParameterType< P1 >::PassObject( param1 ),
 220         ParameterType< P2 >::PassObject( param2 ) );
 221   }
 222
 223 private:
 224
 225   T* object;
 226   MemberFunction memberFunction;
 227   typename ParameterType< P1 >::HolderType param1;
 228   typename ParameterType< P2 >::HolderType param2;
 229
 230 };
 231
 232 /**
 233  * Templated message which calls a member function of an object.
 234  * This overload passes three value-type parameters.
 235  * Template parameters need to match the MemberFunction!
 236  * The message will contain copy of the value (in case of & or const&)
 237  */
 238 template< typename T, typename P1, typename P2, typename P3 >
 239 class MessageValue3 : public MessageBase
 240 {
 241 public:
 242
 243   typedef void(T::*MemberFunction)(
 244       typename ParameterType< P1 >::PassingType,
 245       typename ParameterType< P2 >::PassingType,
 246       typename ParameterType< P3 >::PassingType );
 247
 248   /**
 249    * Create a message.
 250    * @note The object is expected to be const in the thread which sends this message.
 251    * However it can be modified when Process() is called in a different thread.
 252    * @param[in] obj The object.
 253    * @param[in] member The member function of the object.
 254    * @param[in] p1 The first parameter to pass to the member function.
 255    * @param[in] p2 The second parameter to pass to the member function.
 256    * @param[in] p3 The third parameter to pass to the member function.
 257    */
 258   MessageValue3( const T* obj,
 259                  MemberFunction member,
 260                  typename ParameterType< P1 >::PassingType p1,
 261                  typename ParameterType< P2 >::PassingType p2,
 262                  typename ParameterType< P3 >::PassingType p3 )
 263   : MessageBase(),
 264     object( const_cast< T* >( obj ) ),
 265     memberFunction( member ),
 266     param1( p1 ),
 267     param2( p2 ),
 268     param3( p3 )
 269   {
 270   }
 271
 272   /**
 273    * Virtual destructor
 274    */
 275   virtual ~MessageValue3()
 276   {
 277   }
 278
 279   /**
 280    * @copydoc MessageBase::Process
 281    */
 282   virtual void Process( BufferIndex /*bufferIndex*/ )
 283   {
 284     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 285     (object->*memberFunction)(
 286         ParameterType< P1 >::PassObject( param1 ),
 287         ParameterType< P2 >::PassObject( param2 ),
 288         ParameterType< P3 >::PassObject( param3 ) );
 289   }
 290
 291 private:
 292
 293   T* object;
 294   MemberFunction memberFunction;
 295   typename ParameterType< P1 >::HolderType param1;
 296   typename ParameterType< P2 >::HolderType param2;
 297   typename ParameterType< P3 >::HolderType param3;
 298
 299 };
 300
 301 /**
 302  * Templated message which calls a member function of an object.
 303  * This overload passes four value-type parameters.
 304  * Template parameters need to match the MemberFunction!
 305  * The message will contain copy of the value (in case of & or const&)
 306  */
 307 template< typename T, typename P1, typename P2, typename P3, typename P4 >
 308 class MessageValue4 : public MessageBase
 309 {
 310 public:
 311
 312   typedef void(T::*MemberFunction)(
 313       typename ParameterType< P1 >::PassingType,
 314       typename ParameterType< P2 >::PassingType,
 315       typename ParameterType< P3 >::PassingType,
 316       typename ParameterType< P4 >::PassingType );
 317
 318   /**
 319    * Create a message.
 320    * @note The object is expected to be const in the thread which sends this message.
 321    * However it can be modified when Process() is called in a different thread.
 322    * @param[in] obj The object.
 323    * @param[in] member The member function of the object.
 324    * @param[in] p1 The first parameter to pass to the member function.
 325    * @param[in] p2 The second parameter to pass to the member function.
 326    * @param[in] p3 The third parameter to pass to the member function.
 327    * @param[in] p4 The fourth parameter to pass to the member function.
 328    */
 329   MessageValue4( const T* obj,
 330                  MemberFunction member,
 331                  typename ParameterType< P1 >::PassingType p1,
 332                  typename ParameterType< P2 >::PassingType p2,
 333                  typename ParameterType< P3 >::PassingType p3,
 334                  typename ParameterType< P4 >::PassingType p4 )
 335   : MessageBase(),
 336     object( const_cast< T* >( obj ) ),
 337     memberFunction( member ),
 338     param1( p1 ),
 339     param2( p2 ),
 340     param3( p3 ),
 341     param4( p4 )
 342   {
 343   }
 344
 345   /**
 346    * Virtual destructor
 347    */
 348   virtual ~MessageValue4()
 349   {
 350   }
 351
 352   /**
 353    * @copydoc MessageBase::Process
 354    */
 355   virtual void Process( BufferIndex /*bufferIndex*/ )
 356   {
 357     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 358     (object->*memberFunction)(
 359         ParameterType< P1 >::PassObject( param1 ),
 360         ParameterType< P2 >::PassObject( param2 ),
 361         ParameterType< P3 >::PassObject( param3 ),
 362         ParameterType< P4 >::PassObject( param4 ) );
 363   }
 364
 365 private:
 366
 367   T* object;
 368   MemberFunction memberFunction;
 369   typename ParameterType< P1 >::HolderType param1;
 370   typename ParameterType< P2 >::HolderType param2;
 371   typename ParameterType< P3 >::HolderType param3;
 372   typename ParameterType< P4 >::HolderType param4;
 373
 374 };
 375
 376 /**
 377  * Templated message which calls a member function of an object.
 378  * This overload passes five value-type parameters.
 379  * Template parameters need to match the MemberFunction!
 380  * The message will contain copy of the value (in case of & or const&)
 381  */
 382 template< typename T, typename P1, typename P2, typename P3, typename P4, typename P5 >
 383 class MessageValue5 : public MessageBase
 384 {
 385 public:
 386
 387   typedef void(T::*MemberFunction)(
 388       typename ParameterType< P1 >::PassingType,
 389       typename ParameterType< P2 >::PassingType,
 390       typename ParameterType< P3 >::PassingType,
 391       typename ParameterType< P4 >::PassingType,
 392       typename ParameterType< P5 >::PassingType );
 393
 394   /**
 395    * Create a message.
 396    * @note The object is expected to be const in the thread which sends this message.
 397    * However it can be modified when Process() is called in a different thread.
 398    * @param[in] obj The object.
 399    * @param[in] member The member function of the object.
 400    * @param[in] p1 The first parameter to pass to the member function.
 401    * @param[in] p2 The second parameter to pass to the member function.
 402    * @param[in] p3 The third parameter to pass to the member function.
 403    * @param[in] p4 The fourth parameter to pass to the member function.
 404    * @param[in] p5 The fifth parameter to pass to the member function.
 405    */
 406   MessageValue5( const T* obj,
 407                  MemberFunction member,
 408                  typename ParameterType< P1 >::PassingType p1,
 409                  typename ParameterType< P2 >::PassingType p2,
 410                  typename ParameterType< P3 >::PassingType p3,
 411                  typename ParameterType< P4 >::PassingType p4,
 412                  typename ParameterType< P5 >::PassingType p5 )
 413   : MessageBase(),
 414     object( const_cast< T* >( obj ) ),
 415     memberFunction( member ),
 416     param1( p1 ),
 417     param2( p2 ),
 418     param3( p3 ),
 419     param4( p4 ),
 420     param5( p5 )
 421   {
 422   }
 423
 424   /**
 425    * Virtual destructor
 426    */
 427   virtual ~MessageValue5()
 428   {
 429   }
 430
 431   /**
 432    * @copydoc MessageBase::Process
 433    */
 434   virtual void Process( BufferIndex /*bufferIndex*/ )
 435   {
 436     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 437     (object->*memberFunction)(
 438         ParameterType< P1 >::PassObject( param1 ),
 439         ParameterType< P2 >::PassObject( param2 ),
 440         ParameterType< P3 >::PassObject( param3 ),
 441         ParameterType< P4 >::PassObject( param4 ),
 442         ParameterType< P5 >::PassObject( param5 ) );
 443
 444   }
 445
 446 private:
 447
 448   T* object;
 449   MemberFunction memberFunction;
 450   typename ParameterType< P1 >::HolderType param1;
 451   typename ParameterType< P2 >::HolderType param2;
 452   typename ParameterType< P3 >::HolderType param3;
 453   typename ParameterType< P4 >::HolderType param4;
 454   typename ParameterType< P5 >::HolderType param5;
 455
 456 };
 457
 458 /**
 459  * Templated message which calls a member function of an object.
 460  * This overload passes six value-type parameters.
 461  * Template parameters need to match the MemberFunction!
 462  * The message will contain copy of the value (in case of & or const&)
 463  */
 464 template< typename T, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6 >
 465 class MessageValue6 : public MessageBase
 466 {
 467 public:
 468
 469   typedef void(T::*MemberFunction)(
 470       typename ParameterType< P1 >::PassingType,
 471       typename ParameterType< P2 >::PassingType,
 472       typename ParameterType< P3 >::PassingType,
 473       typename ParameterType< P4 >::PassingType,
 474       typename ParameterType< P5 >::PassingType,
 475       typename ParameterType< P6 >::PassingType );
 476
 477   /**
 478    * Create a message.
 479    * @note The object is expected to be const in the thread which sends this message.
 480    * However it can be modified when Process() is called in a different thread.
 481    * @param[in] obj The object.
 482    * @param[in] member The member function of the object.
 483    * @param[in] p1 The first parameter to pass to the member function.
 484    * @param[in] p2 The second parameter to pass to the member function.
 485    * @param[in] p3 The third parameter to pass to the member function.
 486    * @param[in] p4 The fourth parameter to pass to the member function.
 487    * @param[in] p5 The fifth parameter to pass to the member function.
 488    * @param[in] p6 The sixth parameter to pass to the member function.
 489    */
 490   MessageValue6( const T* obj,
 491                  MemberFunction member,
 492                  typename ParameterType< P1 >::PassingType p1,
 493                  typename ParameterType< P2 >::PassingType p2,
 494                  typename ParameterType< P3 >::PassingType p3,
 495                  typename ParameterType< P4 >::PassingType p4,
 496                  typename ParameterType< P5 >::PassingType p5,
 497                  typename ParameterType< P6 >::PassingType p6 )
 498   : MessageBase(),
 499     object( const_cast< T* >( obj ) ),
 500     memberFunction( member ),
 501     param1( p1 ),
 502     param2( p2 ),
 503     param3( p3 ),
 504     param4( p4 ),
 505     param5( p5 ),
 506     param6( p6 )
 507   {
 508   }
 509
 510   /**
 511    * Virtual destructor
 512    */
 513   virtual ~MessageValue6()
 514   {
 515   }
 516
 517   /**
 518    * @copydoc MessageBase::Process
 519    */
 520   virtual void Process( BufferIndex /*bufferIndex*/ )
 521   {
 522     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 523     (object->*memberFunction)(
 524         ParameterType< P1 >::PassObject( param1 ),
 525         ParameterType< P2 >::PassObject( param2 ),
 526         ParameterType< P3 >::PassObject( param3 ),
 527         ParameterType< P4 >::PassObject( param4 ),
 528         ParameterType< P5 >::PassObject( param5 ),
 529         ParameterType< P6 >::PassObject( param6 ) );
 530
 531   }
 532
 533 private:
 534
 535   T* object;
 536   MemberFunction memberFunction;
 537   typename ParameterType< P1 >::HolderType param1;
 538   typename ParameterType< P2 >::HolderType param2;
 539   typename ParameterType< P3 >::HolderType param3;
 540   typename ParameterType< P4 >::HolderType param4;
 541   typename ParameterType< P5 >::HolderType param5;
 542   typename ParameterType< P6 >::HolderType param6;
 543
 544 };
 545
 546 /**
 547  * Templated message which calls a member function of an object.
 548  * This overload passes a value-type to set a double-buffered property.
 549  * Template parameters need to match the MemberFunction!
 550  * The message will contain copy of the value (in case of & or const&)
 551  */
 552 template< typename T, typename P >
 553 class MessageDoubleBuffered1 : public MessageBase
 554 {
 555 public:
 556
 557   typedef void(T::*MemberFunction)(
 558       BufferIndex,
 559       typename ParameterType< P >::PassingType );
 560
 561   /**
 562    * Create a message.
 563    * @note The object is expected to be const in the thread which sends this message.
 564    * However it can be modified when Process() is called in a different thread.
 565    * @param[in] obj The object.
 566    * @param[in] member The member function of the object.
 567    * @param[in] p The second parameter to pass.
 568    */
 569   MessageDoubleBuffered1( const T* obj,
 570                           MemberFunction member,
 571                           typename ParameterType< P >::PassingType p )
 572   : MessageBase(),
 573     object( const_cast< T* >( obj ) ),
 574     memberFunction( member ),
 575     param( p )
 576   {
 577   }
 578
 579   /**
 580    * Virtual destructor
 581    */
 582   virtual ~MessageDoubleBuffered1()
 583   {
 584   }
 585
 586   /**
 587    * @copydoc MessageBase::Process
 588    */
 589   virtual void Process( BufferIndex bufferIndex )
 590   {
 591     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 592     (object->*memberFunction)(
 593         bufferIndex,
 594         ParameterType< P >::PassObject( param ) );
 595   }
 596
 597 private:
 598
 599   T* object;
 600   MemberFunction memberFunction;
 601   typename ParameterType< P >::HolderType param;
 602
 603 };
 604
 605 /**
 606  * Templated message which calls a member function of an object.
 607  * This overload passes two value-types to set double-buffered properties.
 608  * Template parameters need to match the MemberFunction!
 609  * The message will contain copy of the value (in case of & or const&)
 610  */
 611 template< typename T, typename P2, typename P3 >
 612 class MessageDoubleBuffered2 : public MessageBase
 613 {
 614 public:
 615
 616   typedef void(T::*MemberFunction)(
 617       BufferIndex,
 618       typename ParameterType< P2 >::PassingType,
 619       typename ParameterType< P3 >::PassingType );
 620
 621   /**
 622    * Create a message.
 623    * @note The object is expected to be const in the thread which sends this message.
 624    * However it can be modified when Process() is called in a different thread.
 625    * @param[in] obj The object.
 626    * @param[in] member The member function of the object.
 627    * @param[in] p2 The second parameter to pass to the function.
 628    * @param[in] p3 The third parameter to pass to the function.
 629    */
 630   MessageDoubleBuffered2( const T* obj,
 631                           MemberFunction member,
 632                           typename ParameterType< P2 >::PassingType p2,
 633                           typename ParameterType< P3 >::PassingType p3 )
 634   : MessageBase(),
 635     object( const_cast< T* >( obj ) ),
 636     memberFunction( member ),
 637     param2( p2 ),
 638     param3( p3 )
 639   {
 640   }
 641
 642   /**
 643    * Virtual destructor
 644    */
 645   virtual ~MessageDoubleBuffered2()
 646   {
 647   }
 648
 649   /**
 650    * @copydoc MessageBase::Process
 651    */
 652   virtual void Process( BufferIndex bufferIndex )
 653   {
 654     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 655     (object->*memberFunction)(
 656         bufferIndex,
 657         ParameterType< P2 >::PassObject( param2 ),
 658         ParameterType< P3 >::PassObject( param3 ) );
 659   }
 660
 661 private:
 662
 663   T* object;
 664   MemberFunction memberFunction;
 665   typename ParameterType< P2 >::HolderType param2;
 666   typename ParameterType< P3 >::HolderType param3;
 667
 668 };
 669
 670
 671 /**
 672  * Templated message which calls a member function of an object.
 673  * This overload passes three value-types to set double-buffered properties.
 674  * Template parameters need to match the MemberFunction!
 675  * The message will contain copy of the value (in case of & or const&)
 676  */
 677 template< typename T, typename P2, typename P3, typename P4 >
 678 class MessageDoubleBuffered3 : public MessageBase
 679 {
 680 public:
 681
 682   typedef void(T::*MemberFunction)(
 683       BufferIndex,
 684       typename ParameterType< P2 >::PassingType,
 685       typename ParameterType< P3 >::PassingType,
 686       typename ParameterType< P4 >::PassingType );
 687
 688   /**
 689    * Create a message.
 690    * @note The object is expected to be const in the thread which sends this message.
 691    * However it can be modified when Process() is called in a different thread.
 692    * @param[in] obj The object.
 693    * @param[in] member The member function of the object.
 694    * @param[in] p2 The second parameter to pass.
 695    * @param[in] p3 The third parameter to pass.
 696    * @param[in] p4 The forth parameter to pass.
 697    */
 698   MessageDoubleBuffered3( const T* obj,
 699                           MemberFunction member,
 700                           typename ParameterType< P2 >::PassingType p2,
 701                           typename ParameterType< P3 >::PassingType p3,
 702                           typename ParameterType< P4 >::PassingType p4 )
 703   : MessageBase(),
 704     object( const_cast< T* >( obj ) ),
 705     memberFunction( member ),
 706     param2( p2 ),
 707     param3( p3 ),
 708     param4( p4 )
 709   {
 710   }
 711
 712   /**
 713    * Virtual destructor
 714    */
 715   virtual ~MessageDoubleBuffered3()
 716   {
 717   }
 718
 719   /**
 720    * @copydoc MessageBase::Process
 721    */
 722   virtual void Process( BufferIndex bufferIndex )
 723   {
 724     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 725     (object->*memberFunction)(
 726         bufferIndex,
 727         ParameterType< P2 >::PassObject( param2 ),
 728         ParameterType< P3 >::PassObject( param3 ),
 729         ParameterType< P4 >::PassObject( param4 ) );
 730   }
 731
 732 private:
 733
 734   T* object;
 735   MemberFunction memberFunction;
 736   typename ParameterType< P2 >::HolderType param2;
 737   typename ParameterType< P3 >::HolderType param3;
 738   typename ParameterType< P4 >::HolderType param4;
 739
 740 };
 741
 742 /**
 743  * Templated message which calls a member function of an object.
 744  * This overload passes four value-types to set double-buffered properties.
 745  * Template parameters need to match the MemberFunction!
 746  * The message will contain copy of the value (in case of & or const&)
 747  */
 748 template< typename T, typename P2, typename P3, typename P4, typename P5 >
 749 class MessageDoubleBuffered4 : public MessageBase
 750 {
 751 public:
 752
 753   typedef void(T::*MemberFunction)(
 754       BufferIndex,
 755       typename ParameterType< P2 >::PassingType,
 756       typename ParameterType< P3 >::PassingType,
 757       typename ParameterType< P4 >::PassingType,
 758       typename ParameterType< P5 >::PassingType );
 759
 760   /**
 761    * Create a message.
 762    * @note The object is expected to be const in the thread which sends this message.
 763    * However it can be modified when Process() is called in a different thread.
 764    * @param[in] obj The object.
 765    * @param[in] member The member function of the object.
 766    * @param[in] p2 The second parameter to pass.
 767    * @param[in] p3 The third parameter to pass.
 768    * @param[in] p4 The forth parameter to pass.
 769    * @param[in] p5 The fifth parameter to pass.
 770    */
 771   MessageDoubleBuffered4( const T* obj,
 772                           MemberFunction member,
 773                           typename ParameterType< P2 >::PassingType p2,
 774                           typename ParameterType< P3 >::PassingType p3,
 775                           typename ParameterType< P4 >::PassingType p4,
 776                           typename ParameterType< P5 >::PassingType p5 )
 777   : MessageBase(),
 778     object( const_cast< T* >( obj ) ),
 779     memberFunction( member ),
 780     param2( p2 ),
 781     param3( p3 ),
 782     param4( p4 ),
 783     param5( p5 )
 784   {
 785   }
 786
 787   /**
 788    * Virtual destructor
 789    */
 790   virtual ~MessageDoubleBuffered4()
 791   {
 792   }
 793
 794   /**
 795    * @copydoc MessageBase::Process
 796    */
 797   virtual void Process( BufferIndex bufferIndex )
 798   {
 799     DALI_ASSERT_DEBUG( object && "Message does not have an object" );
 800     (object->*memberFunction)(
 801         bufferIndex,
 802         ParameterType< P2 >::PassObject( param2 ),
 803         ParameterType< P3 >::PassObject( param3 ),
 804         ParameterType< P4 >::PassObject( param4 ),
 805         ParameterType< P5 >::PassObject( param5 ) );
 806   }
 807
 808 private:
 809
 810   T* object;
 811   MemberFunction memberFunction;
 812   typename ParameterType< P2 >::HolderType param2;
 813   typename ParameterType< P3 >::HolderType param3;
 814   typename ParameterType< P4 >::HolderType param4;
 815   typename ParameterType< P5 >::HolderType param5;
 816
 817 };
 818
 819 } // namespace Internal
 820
 821 } // namespace Dali
 822
 823 #endif // __DALI_INTERNAL_MESSAGE_H__