00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <sstream>
00024 #include <dbus-cxx/forward_decls.h>
00025 #include <dbus-cxx/utility.h>
00026 #include <dbus-cxx/signal_base.h>
00027
00028 #ifndef DBUSCXX_DBUS_SIGNAL_H_
00029 #define DBUSCXX_DBUS_SIGNAL_H_
00030
00031 namespace DBus {
00032
00048 template <class T_return, class T_arg1 = nil,class T_arg2 = nil,class T_arg3 = nil,class T_arg4 = nil,class T_arg5 = nil,class T_arg6 = nil,class T_arg7 = nil>
00049 class signal
00050 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>, public signal_base
00051 {
00052 public:
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155 typedef DBusCxxPointer<signal> pointer;
00156
00157 signal(const std::string& interface, const std::string& name):
00158 signal_base(interface, name)
00159 {
00160 m_internal_callback_connection =
00161 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00162 }
00163
00164 signal(const std::string& path, const std::string& interface, const std::string& name):
00165 signal_base(path, interface, name)
00166 {
00167 m_internal_callback_connection =
00168 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00169 }
00170
00171 signal(const std::string& interface, const std::string& name, const signal& src) :
00172 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00173 signal_base(interface, name)
00174 { }
00175
00176 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00177 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00178 signal_base(path, interface, name)
00179 { }
00180
00181 static pointer create(const std::string& interface, const std::string& name)
00182 {
00183 return pointer( new signal(interface, name) );
00184 }
00185
00186 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00187 {
00188 return pointer( new signal(path, interface, name) );
00189 }
00190
00191 static pointer create(const std::string& interface, const std::string& name, const signal& src)
00192 {
00193 return pointer( new signal(interface, name, src) );
00194 }
00195
00196 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00197 {
00198 return pointer( new signal(path, interface, name, src) );
00199 }
00200
00201 virtual signal_base::pointer clone()
00202 {
00203 return signal_base::pointer( new signal(*this) );
00204 }
00205
00207 virtual std::string introspect(int space_depth=0) const
00208 {
00209 std::ostringstream sout;
00210 std::string spaces;
00211 for (int i=0; i < space_depth; i++ ) spaces += " ";
00212 sout << spaces << "<signal name=\"" << name() << "\">\n";
00213
00214 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
00215 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
00216 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
00217 sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
00218 sout << spaces << " <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature<T_arg5>() << "\"/>\n";
00219 sout << spaces << " <arg name=\"" << m_arg_names[6-1] << "\" type=\"" << signature<T_arg6>() << "\"/>\n";
00220 sout << spaces << " <arg name=\"" << m_arg_names[7-1] << "\" type=\"" << signature<T_arg7>() << "\"/>\n";
00221 sout << spaces << "</signal>\n";
00222 return sout.str();
00223 }
00224
00225 virtual std::string arg_name(size_t i) {
00226 if ( i < 7 ) return m_arg_names[i];
00227 return std::string();
00228 }
00229
00230 virtual void set_arg_name(size_t i, const std::string& name) {
00231 if ( i < 7 ) m_arg_names[i] = name;
00232 }
00233
00234 protected:
00235
00236 friend class Interface;
00237
00238 std::string m_arg_names[7];
00239
00240 sigc::connection m_internal_callback_connection;
00241
00242 T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6,T_arg7 arg7)
00243 {
00244
00245 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00246 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00247 *__msg << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7;
00248 #ifdef DBUS_CXX_DEBUG_ENABLED
00249 bool result = this->handle_dbus_outgoing(__msg);
00250 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00251 #else
00252 this->handle_dbus_outgoing(__msg);
00253 #endif
00254 }
00255
00256 };
00257
00258
00259
00275 template <class T_return>
00276 class signal <T_return, nil,nil,nil,nil,nil,nil,nil>
00277 : public sigc::signal<T_return>, public signal_base
00278 {
00279 public:
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374
00375 typedef DBusCxxPointer<signal> pointer;
00376
00377 signal(const std::string& interface, const std::string& name):
00378 signal_base(interface, name)
00379 {
00380 m_internal_callback_connection =
00381 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00382 }
00383
00384 signal(const std::string& path, const std::string& interface, const std::string& name):
00385 signal_base(path, interface, name)
00386 {
00387 m_internal_callback_connection =
00388 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00389 }
00390
00391 signal(const std::string& interface, const std::string& name, const signal& src) :
00392 sigc::signal<T_return>(src),
00393 signal_base(interface, name)
00394 { }
00395
00396 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00397 sigc::signal<T_return>(src),
00398 signal_base(path, interface, name)
00399 { }
00400
00401 static pointer create(const std::string& interface, const std::string& name)
00402 {
00403 return pointer( new signal(interface, name) );
00404 }
00405
00406 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00407 {
00408 return pointer( new signal(path, interface, name) );
00409 }
00410
00411 static pointer create(const std::string& interface, const std::string& name, const signal& src)
00412 {
00413 return pointer( new signal(interface, name, src) );
00414 }
00415
00416 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00417 {
00418 return pointer( new signal(path, interface, name, src) );
00419 }
00420
00421 virtual signal_base::pointer clone()
00422 {
00423 return signal_base::pointer( new signal(*this) );
00424 }
00425
00427 virtual std::string introspect(int space_depth=0) const
00428 {
00429 std::ostringstream sout;
00430 std::string spaces;
00431 for (int i=0; i < space_depth; i++ ) spaces += " ";
00432 sout << spaces << "<signal name=\"" << name() << "\">\n";
00433
00434 sout << spaces << "</signal>\n";
00435 return sout.str();
00436 }
00437
00438 virtual std::string arg_name(size_t i) {
00439 if ( i < 0 ) return m_arg_names[i];
00440 return std::string();
00441 }
00442
00443 virtual void set_arg_name(size_t i, const std::string& name) {
00444 if ( i < 0 ) m_arg_names[i] = name;
00445 }
00446
00447 protected:
00448
00449 friend class Interface;
00450
00451 std::string m_arg_names[0];
00452
00453 sigc::connection m_internal_callback_connection;
00454
00455 T_return internal_callback()
00456 {
00457
00458 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00459 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00460
00461 #ifdef DBUS_CXX_DEBUG_ENABLED
00462 bool result = this->handle_dbus_outgoing(__msg);
00463 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00464 #else
00465 this->handle_dbus_outgoing(__msg);
00466 #endif
00467 }
00468
00469 };
00470
00471
00487 template <class T_return, class T_arg1>
00488 class signal <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00489 : public sigc::signal<T_return, T_arg1>, public signal_base
00490 {
00491 public:
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588 typedef DBusCxxPointer<signal> pointer;
00589
00590 signal(const std::string& interface, const std::string& name):
00591 signal_base(interface, name)
00592 {
00593 m_internal_callback_connection =
00594 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00595 }
00596
00597 signal(const std::string& path, const std::string& interface, const std::string& name):
00598 signal_base(path, interface, name)
00599 {
00600 m_internal_callback_connection =
00601 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00602 }
00603
00604 signal(const std::string& interface, const std::string& name, const signal& src) :
00605 sigc::signal<T_return, T_arg1>(src),
00606 signal_base(interface, name)
00607 { }
00608
00609 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00610 sigc::signal<T_return, T_arg1>(src),
00611 signal_base(path, interface, name)
00612 { }
00613
00614 static pointer create(const std::string& interface, const std::string& name)
00615 {
00616 return pointer( new signal(interface, name) );
00617 }
00618
00619 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00620 {
00621 return pointer( new signal(path, interface, name) );
00622 }
00623
00624 static pointer create(const std::string& interface, const std::string& name, const signal& src)
00625 {
00626 return pointer( new signal(interface, name, src) );
00627 }
00628
00629 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00630 {
00631 return pointer( new signal(path, interface, name, src) );
00632 }
00633
00634 virtual signal_base::pointer clone()
00635 {
00636 return signal_base::pointer( new signal(*this) );
00637 }
00638
00640 virtual std::string introspect(int space_depth=0) const
00641 {
00642 std::ostringstream sout;
00643 std::string spaces;
00644 for (int i=0; i < space_depth; i++ ) spaces += " ";
00645 sout << spaces << "<signal name=\"" << name() << "\">\n";
00646
00647 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
00648 sout << spaces << "</signal>\n";
00649 return sout.str();
00650 }
00651
00652 virtual std::string arg_name(size_t i) {
00653 if ( i < 1 ) return m_arg_names[i];
00654 return std::string();
00655 }
00656
00657 virtual void set_arg_name(size_t i, const std::string& name) {
00658 if ( i < 1 ) m_arg_names[i] = name;
00659 }
00660
00661 protected:
00662
00663 friend class Interface;
00664
00665 std::string m_arg_names[1];
00666
00667 sigc::connection m_internal_callback_connection;
00668
00669 T_return internal_callback(T_arg1 arg1)
00670 {
00671
00672 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00673 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00674 *__msg << arg1;
00675 #ifdef DBUS_CXX_DEBUG_ENABLED
00676 bool result = this->handle_dbus_outgoing(__msg);
00677 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00678 #else
00679 this->handle_dbus_outgoing(__msg);
00680 #endif
00681 }
00682
00683 };
00684
00685
00701 template <class T_return, class T_arg1,class T_arg2>
00702 class signal <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00703 : public sigc::signal<T_return, T_arg1,T_arg2>, public signal_base
00704 {
00705 public:
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803 typedef DBusCxxPointer<signal> pointer;
00804
00805 signal(const std::string& interface, const std::string& name):
00806 signal_base(interface, name)
00807 {
00808 m_internal_callback_connection =
00809 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00810 }
00811
00812 signal(const std::string& path, const std::string& interface, const std::string& name):
00813 signal_base(path, interface, name)
00814 {
00815 m_internal_callback_connection =
00816 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00817 }
00818
00819 signal(const std::string& interface, const std::string& name, const signal& src) :
00820 sigc::signal<T_return, T_arg1,T_arg2>(src),
00821 signal_base(interface, name)
00822 { }
00823
00824 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00825 sigc::signal<T_return, T_arg1,T_arg2>(src),
00826 signal_base(path, interface, name)
00827 { }
00828
00829 static pointer create(const std::string& interface, const std::string& name)
00830 {
00831 return pointer( new signal(interface, name) );
00832 }
00833
00834 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00835 {
00836 return pointer( new signal(path, interface, name) );
00837 }
00838
00839 static pointer create(const std::string& interface, const std::string& name, const signal& src)
00840 {
00841 return pointer( new signal(interface, name, src) );
00842 }
00843
00844 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00845 {
00846 return pointer( new signal(path, interface, name, src) );
00847 }
00848
00849 virtual signal_base::pointer clone()
00850 {
00851 return signal_base::pointer( new signal(*this) );
00852 }
00853
00855 virtual std::string introspect(int space_depth=0) const
00856 {
00857 std::ostringstream sout;
00858 std::string spaces;
00859 for (int i=0; i < space_depth; i++ ) spaces += " ";
00860 sout << spaces << "<signal name=\"" << name() << "\">\n";
00861
00862 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
00863 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
00864 sout << spaces << "</signal>\n";
00865 return sout.str();
00866 }
00867
00868 virtual std::string arg_name(size_t i) {
00869 if ( i < 2 ) return m_arg_names[i];
00870 return std::string();
00871 }
00872
00873 virtual void set_arg_name(size_t i, const std::string& name) {
00874 if ( i < 2 ) m_arg_names[i] = name;
00875 }
00876
00877 protected:
00878
00879 friend class Interface;
00880
00881 std::string m_arg_names[2];
00882
00883 sigc::connection m_internal_callback_connection;
00884
00885 T_return internal_callback(T_arg1 arg1,T_arg2 arg2)
00886 {
00887
00888 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00889 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00890 *__msg << arg1 << arg2;
00891 #ifdef DBUS_CXX_DEBUG_ENABLED
00892 bool result = this->handle_dbus_outgoing(__msg);
00893 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00894 #else
00895 this->handle_dbus_outgoing(__msg);
00896 #endif
00897 }
00898
00899 };
00900
00901
00917 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00918 class signal <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00919 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3>, public signal_base
00920 {
00921 public:
00922
00923
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020 typedef DBusCxxPointer<signal> pointer;
01021
01022 signal(const std::string& interface, const std::string& name):
01023 signal_base(interface, name)
01024 {
01025 m_internal_callback_connection =
01026 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01027 }
01028
01029 signal(const std::string& path, const std::string& interface, const std::string& name):
01030 signal_base(path, interface, name)
01031 {
01032 m_internal_callback_connection =
01033 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01034 }
01035
01036 signal(const std::string& interface, const std::string& name, const signal& src) :
01037 sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
01038 signal_base(interface, name)
01039 { }
01040
01041 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01042 sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
01043 signal_base(path, interface, name)
01044 { }
01045
01046 static pointer create(const std::string& interface, const std::string& name)
01047 {
01048 return pointer( new signal(interface, name) );
01049 }
01050
01051 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01052 {
01053 return pointer( new signal(path, interface, name) );
01054 }
01055
01056 static pointer create(const std::string& interface, const std::string& name, const signal& src)
01057 {
01058 return pointer( new signal(interface, name, src) );
01059 }
01060
01061 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01062 {
01063 return pointer( new signal(path, interface, name, src) );
01064 }
01065
01066 virtual signal_base::pointer clone()
01067 {
01068 return signal_base::pointer( new signal(*this) );
01069 }
01070
01072 virtual std::string introspect(int space_depth=0) const
01073 {
01074 std::ostringstream sout;
01075 std::string spaces;
01076 for (int i=0; i < space_depth; i++ ) spaces += " ";
01077 sout << spaces << "<signal name=\"" << name() << "\">\n";
01078
01079 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01080 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01081 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01082 sout << spaces << "</signal>\n";
01083 return sout.str();
01084 }
01085
01086 virtual std::string arg_name(size_t i) {
01087 if ( i < 3 ) return m_arg_names[i];
01088 return std::string();
01089 }
01090
01091 virtual void set_arg_name(size_t i, const std::string& name) {
01092 if ( i < 3 ) m_arg_names[i] = name;
01093 }
01094
01095 protected:
01096
01097 friend class Interface;
01098
01099 std::string m_arg_names[3];
01100
01101 sigc::connection m_internal_callback_connection;
01102
01103 T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3)
01104 {
01105
01106 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01107 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01108 *__msg << arg1 << arg2 << arg3;
01109 #ifdef DBUS_CXX_DEBUG_ENABLED
01110 bool result = this->handle_dbus_outgoing(__msg);
01111 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01112 #else
01113 this->handle_dbus_outgoing(__msg);
01114 #endif
01115 }
01116
01117 };
01118
01119
01135 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
01136 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
01137 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>, public signal_base
01138 {
01139 public:
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172
01173
01174
01175
01176
01177
01178
01179
01180
01181
01182
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239 typedef DBusCxxPointer<signal> pointer;
01240
01241 signal(const std::string& interface, const std::string& name):
01242 signal_base(interface, name)
01243 {
01244 m_internal_callback_connection =
01245 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01246 }
01247
01248 signal(const std::string& path, const std::string& interface, const std::string& name):
01249 signal_base(path, interface, name)
01250 {
01251 m_internal_callback_connection =
01252 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01253 }
01254
01255 signal(const std::string& interface, const std::string& name, const signal& src) :
01256 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
01257 signal_base(interface, name)
01258 { }
01259
01260 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01261 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
01262 signal_base(path, interface, name)
01263 { }
01264
01265 static pointer create(const std::string& interface, const std::string& name)
01266 {
01267 return pointer( new signal(interface, name) );
01268 }
01269
01270 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01271 {
01272 return pointer( new signal(path, interface, name) );
01273 }
01274
01275 static pointer create(const std::string& interface, const std::string& name, const signal& src)
01276 {
01277 return pointer( new signal(interface, name, src) );
01278 }
01279
01280 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01281 {
01282 return pointer( new signal(path, interface, name, src) );
01283 }
01284
01285 virtual signal_base::pointer clone()
01286 {
01287 return signal_base::pointer( new signal(*this) );
01288 }
01289
01291 virtual std::string introspect(int space_depth=0) const
01292 {
01293 std::ostringstream sout;
01294 std::string spaces;
01295 for (int i=0; i < space_depth; i++ ) spaces += " ";
01296 sout << spaces << "<signal name=\"" << name() << "\">\n";
01297
01298 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01299 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01300 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01301 sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
01302 sout << spaces << "</signal>\n";
01303 return sout.str();
01304 }
01305
01306 virtual std::string arg_name(size_t i) {
01307 if ( i < 4 ) return m_arg_names[i];
01308 return std::string();
01309 }
01310
01311 virtual void set_arg_name(size_t i, const std::string& name) {
01312 if ( i < 4 ) m_arg_names[i] = name;
01313 }
01314
01315 protected:
01316
01317 friend class Interface;
01318
01319 std::string m_arg_names[4];
01320
01321 sigc::connection m_internal_callback_connection;
01322
01323 T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4)
01324 {
01325
01326 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01327 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01328 *__msg << arg1 << arg2 << arg3 << arg4;
01329 #ifdef DBUS_CXX_DEBUG_ENABLED
01330 bool result = this->handle_dbus_outgoing(__msg);
01331 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01332 #else
01333 this->handle_dbus_outgoing(__msg);
01334 #endif
01335 }
01336
01337 };
01338
01339
01355 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
01356 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
01357 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>, public signal_base
01358 {
01359 public:
01360
01361
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372
01373
01374
01375
01376
01377
01378
01379
01380
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415
01416
01417
01418
01419
01420
01421
01422
01423
01424
01425
01426
01427
01428
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440
01441
01442
01443
01444
01445
01446
01447
01448
01449
01450
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460 typedef DBusCxxPointer<signal> pointer;
01461
01462 signal(const std::string& interface, const std::string& name):
01463 signal_base(interface, name)
01464 {
01465 m_internal_callback_connection =
01466 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01467 }
01468
01469 signal(const std::string& path, const std::string& interface, const std::string& name):
01470 signal_base(path, interface, name)
01471 {
01472 m_internal_callback_connection =
01473 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01474 }
01475
01476 signal(const std::string& interface, const std::string& name, const signal& src) :
01477 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
01478 signal_base(interface, name)
01479 { }
01480
01481 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01482 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
01483 signal_base(path, interface, name)
01484 { }
01485
01486 static pointer create(const std::string& interface, const std::string& name)
01487 {
01488 return pointer( new signal(interface, name) );
01489 }
01490
01491 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01492 {
01493 return pointer( new signal(path, interface, name) );
01494 }
01495
01496 static pointer create(const std::string& interface, const std::string& name, const signal& src)
01497 {
01498 return pointer( new signal(interface, name, src) );
01499 }
01500
01501 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01502 {
01503 return pointer( new signal(path, interface, name, src) );
01504 }
01505
01506 virtual signal_base::pointer clone()
01507 {
01508 return signal_base::pointer( new signal(*this) );
01509 }
01510
01512 virtual std::string introspect(int space_depth=0) const
01513 {
01514 std::ostringstream sout;
01515 std::string spaces;
01516 for (int i=0; i < space_depth; i++ ) spaces += " ";
01517 sout << spaces << "<signal name=\"" << name() << "\">\n";
01518
01519 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01520 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01521 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01522 sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
01523 sout << spaces << " <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature<T_arg5>() << "\"/>\n";
01524 sout << spaces << "</signal>\n";
01525 return sout.str();
01526 }
01527
01528 virtual std::string arg_name(size_t i) {
01529 if ( i < 5 ) return m_arg_names[i];
01530 return std::string();
01531 }
01532
01533 virtual void set_arg_name(size_t i, const std::string& name) {
01534 if ( i < 5 ) m_arg_names[i] = name;
01535 }
01536
01537 protected:
01538
01539 friend class Interface;
01540
01541 std::string m_arg_names[5];
01542
01543 sigc::connection m_internal_callback_connection;
01544
01545 T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5)
01546 {
01547
01548 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01549 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01550 *__msg << arg1 << arg2 << arg3 << arg4 << arg5;
01551 #ifdef DBUS_CXX_DEBUG_ENABLED
01552 bool result = this->handle_dbus_outgoing(__msg);
01553 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01554 #else
01555 this->handle_dbus_outgoing(__msg);
01556 #endif
01557 }
01558
01559 };
01560
01561
01577 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
01578 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
01579 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>, public signal_base
01580 {
01581 public:
01582
01583
01584
01585
01586
01587
01588
01589
01590
01591
01592
01593
01594
01595
01596
01597
01598
01599
01600
01601
01602
01603
01604
01605
01606
01607
01608
01609
01610
01611
01612
01613
01614
01615
01616
01617
01618
01619
01620
01621
01622
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646
01647
01648
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659
01660
01661
01662
01663
01664
01665
01666
01667
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678
01679
01680
01681
01682
01683 typedef DBusCxxPointer<signal> pointer;
01684
01685 signal(const std::string& interface, const std::string& name):
01686 signal_base(interface, name)
01687 {
01688 m_internal_callback_connection =
01689 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01690 }
01691
01692 signal(const std::string& path, const std::string& interface, const std::string& name):
01693 signal_base(path, interface, name)
01694 {
01695 m_internal_callback_connection =
01696 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01697 }
01698
01699 signal(const std::string& interface, const std::string& name, const signal& src) :
01700 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
01701 signal_base(interface, name)
01702 { }
01703
01704 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01705 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
01706 signal_base(path, interface, name)
01707 { }
01708
01709 static pointer create(const std::string& interface, const std::string& name)
01710 {
01711 return pointer( new signal(interface, name) );
01712 }
01713
01714 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01715 {
01716 return pointer( new signal(path, interface, name) );
01717 }
01718
01719 static pointer create(const std::string& interface, const std::string& name, const signal& src)
01720 {
01721 return pointer( new signal(interface, name, src) );
01722 }
01723
01724 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01725 {
01726 return pointer( new signal(path, interface, name, src) );
01727 }
01728
01729 virtual signal_base::pointer clone()
01730 {
01731 return signal_base::pointer( new signal(*this) );
01732 }
01733
01735 virtual std::string introspect(int space_depth=0) const
01736 {
01737 std::ostringstream sout;
01738 std::string spaces;
01739 for (int i=0; i < space_depth; i++ ) spaces += " ";
01740 sout << spaces << "<signal name=\"" << name() << "\">\n";
01741
01742 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01743 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01744 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01745 sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
01746 sout << spaces << " <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature<T_arg5>() << "\"/>\n";
01747 sout << spaces << " <arg name=\"" << m_arg_names[6-1] << "\" type=\"" << signature<T_arg6>() << "\"/>\n";
01748 sout << spaces << "</signal>\n";
01749 return sout.str();
01750 }
01751
01752 virtual std::string arg_name(size_t i) {
01753 if ( i < 6 ) return m_arg_names[i];
01754 return std::string();
01755 }
01756
01757 virtual void set_arg_name(size_t i, const std::string& name) {
01758 if ( i < 6 ) m_arg_names[i] = name;
01759 }
01760
01761 protected:
01762
01763 friend class Interface;
01764
01765 std::string m_arg_names[6];
01766
01767 sigc::connection m_internal_callback_connection;
01768
01769 T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6)
01770 {
01771
01772 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01773 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01774 *__msg << arg1 << arg2 << arg3 << arg4 << arg5 << arg6;
01775 #ifdef DBUS_CXX_DEBUG_ENABLED
01776 bool result = this->handle_dbus_outgoing(__msg);
01777 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01778 #else
01779 this->handle_dbus_outgoing(__msg);
01780 #endif
01781 }
01782
01783 };
01784
01785
01786
01787 }
01788
01789 #endif