00001
00002
00003
00004
00005 #ifndef DBUS_CXX_SIGNAL_H_
00006 #define DBUS_CXX_SIGNAL_H_
00007
00008 #include <sstream>
00009 #include <dbus-cxx/signal_base.h>
00010
00011 namespace DBus {
00012
00013 class Interface;
00014
00030 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>
00031 class signal
00032 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>, public signal_base
00033 {
00034 public:
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
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 typedef DBusCxxPointer<signal> pointer;
00138
00139 signal(const std::string& interface, const std::string& name):
00140 signal_base(interface, name)
00141 {
00142 m_internal_callback_connection =
00143 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00144 }
00145
00146 signal(const std::string& path, const std::string& interface, const std::string& name):
00147 signal_base(path, interface, name)
00148 {
00149 m_internal_callback_connection =
00150 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00151 }
00152
00153 signal(const std::string& interface, const std::string& name, const signal& src) :
00154 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00155 signal_base(interface, name)
00156 { }
00157
00158 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00159 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(src),
00160 signal_base(path, interface, name)
00161 { }
00162
00163 static pointer create(const std::string& interface, const std::string& name)
00164 {
00165 return pointer( new signal(interface, name) );
00166 }
00167
00168 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00169 {
00170 return pointer( new signal(path, interface, name) );
00171 }
00172
00173 static pointer create(const std::string& interface, const std::string& name, const signal& src)
00174 {
00175 return pointer( new signal(interface, name, src) );
00176 }
00177
00178 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00179 {
00180 return pointer( new signal(path, interface, name, src) );
00181 }
00182
00183 virtual signal_base::pointer clone()
00184 {
00185 return signal_base::pointer( new signal(*this) );
00186 }
00187
00189 virtual std::string introspect(int space_depth=0) const
00190 {
00191 std::ostringstream sout;
00192 std::string spaces;
00193 for (int i=0; i < space_depth; i++ ) spaces += " ";
00194 sout << spaces << "<signal name=\"" << name() << "\">\n";
00195
00196 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
00197 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
00198 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
00199 sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
00200 sout << spaces << " <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature<T_arg5>() << "\"/>\n";
00201 sout << spaces << " <arg name=\"" << m_arg_names[6-1] << "\" type=\"" << signature<T_arg6>() << "\"/>\n";
00202 sout << spaces << " <arg name=\"" << m_arg_names[7-1] << "\" type=\"" << signature<T_arg7>() << "\"/>\n";
00203 sout << spaces << "</signal>\n";
00204 return sout.str();
00205 }
00206
00207 virtual std::string arg_name(size_t i) {
00208 if ( i < 7 ) return m_arg_names[i];
00209 return std::string();
00210 }
00211
00212 virtual void set_arg_name(size_t i, const std::string& name) {
00213 if ( i < 7 ) m_arg_names[i] = name;
00214 }
00215
00216 protected:
00217
00218 friend class Interface;
00219
00220 std::string m_arg_names[7];
00221
00222 sigc::connection m_internal_callback_connection;
00223
00224 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)
00225 {
00226 DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7 );
00227 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00228 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00229 *__msg << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 << arg7;
00230 #ifdef DBUS_CXX_DEBUG_ENABLED
00231 bool result = this->handle_dbus_outgoing(__msg);
00232 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00233 #else
00234 this->handle_dbus_outgoing(__msg);
00235 #endif
00236 }
00237
00238 };
00239
00240
00241
00257 template <class T_return>
00258 class signal <T_return, nil,nil,nil,nil,nil,nil,nil>
00259 : public sigc::signal<T_return>, public signal_base
00260 {
00261 public:
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
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 typedef DBusCxxPointer<signal> pointer;
00358
00359 signal(const std::string& interface, const std::string& name):
00360 signal_base(interface, name)
00361 {
00362 m_internal_callback_connection =
00363 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00364 }
00365
00366 signal(const std::string& path, const std::string& interface, const std::string& name):
00367 signal_base(path, interface, name)
00368 {
00369 m_internal_callback_connection =
00370 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00371 }
00372
00373 signal(const std::string& interface, const std::string& name, const signal& src) :
00374 sigc::signal<T_return>(src),
00375 signal_base(interface, name)
00376 { }
00377
00378 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00379 sigc::signal<T_return>(src),
00380 signal_base(path, interface, name)
00381 { }
00382
00383 static pointer create(const std::string& interface, const std::string& name)
00384 {
00385 return pointer( new signal(interface, name) );
00386 }
00387
00388 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00389 {
00390 return pointer( new signal(path, interface, name) );
00391 }
00392
00393 static pointer create(const std::string& interface, const std::string& name, const signal& src)
00394 {
00395 return pointer( new signal(interface, name, src) );
00396 }
00397
00398 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00399 {
00400 return pointer( new signal(path, interface, name, src) );
00401 }
00402
00403 virtual signal_base::pointer clone()
00404 {
00405 return signal_base::pointer( new signal(*this) );
00406 }
00407
00409 virtual std::string introspect(int space_depth=0) const
00410 {
00411 std::ostringstream sout;
00412 std::string spaces;
00413 for (int i=0; i < space_depth; i++ ) spaces += " ";
00414 sout << spaces << "<signal name=\"" << name() << "\">\n";
00415
00416 sout << spaces << "</signal>\n";
00417 return sout.str();
00418 }
00419
00420 virtual std::string arg_name(size_t i) {
00421 if ( i < 0 ) return m_arg_names[i];
00422 return std::string();
00423 }
00424
00425 virtual void set_arg_name(size_t i, const std::string& name) {
00426 if ( i < 0 ) m_arg_names[i] = name;
00427 }
00428
00429 protected:
00430
00431 friend class Interface;
00432
00433 std::string m_arg_names[0];
00434
00435 sigc::connection m_internal_callback_connection;
00436
00437 T_return internal_callback()
00438 {
00439 DBUS_CXX_DEBUG( "signal::internal_callback: " );
00440 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00441 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00442
00443 #ifdef DBUS_CXX_DEBUG_ENABLED
00444 bool result = this->handle_dbus_outgoing(__msg);
00445 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00446 #else
00447 this->handle_dbus_outgoing(__msg);
00448 #endif
00449 }
00450
00451 };
00452
00453
00469 template <class T_return, class T_arg1>
00470 class signal <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
00471 : public sigc::signal<T_return, T_arg1>, public signal_base
00472 {
00473 public:
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
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 typedef DBusCxxPointer<signal> pointer;
00571
00572 signal(const std::string& interface, const std::string& name):
00573 signal_base(interface, name)
00574 {
00575 m_internal_callback_connection =
00576 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00577 }
00578
00579 signal(const std::string& path, const std::string& interface, const std::string& name):
00580 signal_base(path, interface, name)
00581 {
00582 m_internal_callback_connection =
00583 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00584 }
00585
00586 signal(const std::string& interface, const std::string& name, const signal& src) :
00587 sigc::signal<T_return, T_arg1>(src),
00588 signal_base(interface, name)
00589 { }
00590
00591 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00592 sigc::signal<T_return, T_arg1>(src),
00593 signal_base(path, interface, name)
00594 { }
00595
00596 static pointer create(const std::string& interface, const std::string& name)
00597 {
00598 return pointer( new signal(interface, name) );
00599 }
00600
00601 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00602 {
00603 return pointer( new signal(path, interface, name) );
00604 }
00605
00606 static pointer create(const std::string& interface, const std::string& name, const signal& src)
00607 {
00608 return pointer( new signal(interface, name, src) );
00609 }
00610
00611 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00612 {
00613 return pointer( new signal(path, interface, name, src) );
00614 }
00615
00616 virtual signal_base::pointer clone()
00617 {
00618 return signal_base::pointer( new signal(*this) );
00619 }
00620
00622 virtual std::string introspect(int space_depth=0) const
00623 {
00624 std::ostringstream sout;
00625 std::string spaces;
00626 for (int i=0; i < space_depth; i++ ) spaces += " ";
00627 sout << spaces << "<signal name=\"" << name() << "\">\n";
00628
00629 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
00630 sout << spaces << "</signal>\n";
00631 return sout.str();
00632 }
00633
00634 virtual std::string arg_name(size_t i) {
00635 if ( i < 1 ) return m_arg_names[i];
00636 return std::string();
00637 }
00638
00639 virtual void set_arg_name(size_t i, const std::string& name) {
00640 if ( i < 1 ) m_arg_names[i] = name;
00641 }
00642
00643 protected:
00644
00645 friend class Interface;
00646
00647 std::string m_arg_names[1];
00648
00649 sigc::connection m_internal_callback_connection;
00650
00651 T_return internal_callback(T_arg1 arg1)
00652 {
00653 DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 );
00654 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00655 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00656 *__msg << arg1;
00657 #ifdef DBUS_CXX_DEBUG_ENABLED
00658 bool result = this->handle_dbus_outgoing(__msg);
00659 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00660 #else
00661 this->handle_dbus_outgoing(__msg);
00662 #endif
00663 }
00664
00665 };
00666
00667
00683 template <class T_return, class T_arg1,class T_arg2>
00684 class signal <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
00685 : public sigc::signal<T_return, T_arg1,T_arg2>, public signal_base
00686 {
00687 public:
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
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 typedef DBusCxxPointer<signal> pointer;
00786
00787 signal(const std::string& interface, const std::string& name):
00788 signal_base(interface, name)
00789 {
00790 m_internal_callback_connection =
00791 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00792 }
00793
00794 signal(const std::string& path, const std::string& interface, const std::string& name):
00795 signal_base(path, interface, name)
00796 {
00797 m_internal_callback_connection =
00798 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
00799 }
00800
00801 signal(const std::string& interface, const std::string& name, const signal& src) :
00802 sigc::signal<T_return, T_arg1,T_arg2>(src),
00803 signal_base(interface, name)
00804 { }
00805
00806 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
00807 sigc::signal<T_return, T_arg1,T_arg2>(src),
00808 signal_base(path, interface, name)
00809 { }
00810
00811 static pointer create(const std::string& interface, const std::string& name)
00812 {
00813 return pointer( new signal(interface, name) );
00814 }
00815
00816 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
00817 {
00818 return pointer( new signal(path, interface, name) );
00819 }
00820
00821 static pointer create(const std::string& interface, const std::string& name, const signal& src)
00822 {
00823 return pointer( new signal(interface, name, src) );
00824 }
00825
00826 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
00827 {
00828 return pointer( new signal(path, interface, name, src) );
00829 }
00830
00831 virtual signal_base::pointer clone()
00832 {
00833 return signal_base::pointer( new signal(*this) );
00834 }
00835
00837 virtual std::string introspect(int space_depth=0) const
00838 {
00839 std::ostringstream sout;
00840 std::string spaces;
00841 for (int i=0; i < space_depth; i++ ) spaces += " ";
00842 sout << spaces << "<signal name=\"" << name() << "\">\n";
00843
00844 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
00845 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
00846 sout << spaces << "</signal>\n";
00847 return sout.str();
00848 }
00849
00850 virtual std::string arg_name(size_t i) {
00851 if ( i < 2 ) return m_arg_names[i];
00852 return std::string();
00853 }
00854
00855 virtual void set_arg_name(size_t i, const std::string& name) {
00856 if ( i < 2 ) m_arg_names[i] = name;
00857 }
00858
00859 protected:
00860
00861 friend class Interface;
00862
00863 std::string m_arg_names[2];
00864
00865 sigc::connection m_internal_callback_connection;
00866
00867 T_return internal_callback(T_arg1 arg1,T_arg2 arg2)
00868 {
00869 DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 );
00870 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
00871 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
00872 *__msg << arg1 << arg2;
00873 #ifdef DBUS_CXX_DEBUG_ENABLED
00874 bool result = this->handle_dbus_outgoing(__msg);
00875 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
00876 #else
00877 this->handle_dbus_outgoing(__msg);
00878 #endif
00879 }
00880
00881 };
00882
00883
00899 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
00900 class signal <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
00901 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3>, public signal_base
00902 {
00903 public:
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
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 typedef DBusCxxPointer<signal> pointer;
01003
01004 signal(const std::string& interface, const std::string& name):
01005 signal_base(interface, name)
01006 {
01007 m_internal_callback_connection =
01008 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01009 }
01010
01011 signal(const std::string& path, const std::string& interface, const std::string& name):
01012 signal_base(path, interface, name)
01013 {
01014 m_internal_callback_connection =
01015 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01016 }
01017
01018 signal(const std::string& interface, const std::string& name, const signal& src) :
01019 sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
01020 signal_base(interface, name)
01021 { }
01022
01023 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01024 sigc::signal<T_return, T_arg1,T_arg2,T_arg3>(src),
01025 signal_base(path, interface, name)
01026 { }
01027
01028 static pointer create(const std::string& interface, const std::string& name)
01029 {
01030 return pointer( new signal(interface, name) );
01031 }
01032
01033 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01034 {
01035 return pointer( new signal(path, interface, name) );
01036 }
01037
01038 static pointer create(const std::string& interface, const std::string& name, const signal& src)
01039 {
01040 return pointer( new signal(interface, name, src) );
01041 }
01042
01043 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01044 {
01045 return pointer( new signal(path, interface, name, src) );
01046 }
01047
01048 virtual signal_base::pointer clone()
01049 {
01050 return signal_base::pointer( new signal(*this) );
01051 }
01052
01054 virtual std::string introspect(int space_depth=0) const
01055 {
01056 std::ostringstream sout;
01057 std::string spaces;
01058 for (int i=0; i < space_depth; i++ ) spaces += " ";
01059 sout << spaces << "<signal name=\"" << name() << "\">\n";
01060
01061 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01062 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01063 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01064 sout << spaces << "</signal>\n";
01065 return sout.str();
01066 }
01067
01068 virtual std::string arg_name(size_t i) {
01069 if ( i < 3 ) return m_arg_names[i];
01070 return std::string();
01071 }
01072
01073 virtual void set_arg_name(size_t i, const std::string& name) {
01074 if ( i < 3 ) m_arg_names[i] = name;
01075 }
01076
01077 protected:
01078
01079 friend class Interface;
01080
01081 std::string m_arg_names[3];
01082
01083 sigc::connection m_internal_callback_connection;
01084
01085 T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3)
01086 {
01087 DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 );
01088 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01089 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01090 *__msg << arg1 << arg2 << arg3;
01091 #ifdef DBUS_CXX_DEBUG_ENABLED
01092 bool result = this->handle_dbus_outgoing(__msg);
01093 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01094 #else
01095 this->handle_dbus_outgoing(__msg);
01096 #endif
01097 }
01098
01099 };
01100
01101
01117 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
01118 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
01119 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>, public signal_base
01120 {
01121 public:
01122
01123
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
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 typedef DBusCxxPointer<signal> pointer;
01222
01223 signal(const std::string& interface, const std::string& name):
01224 signal_base(interface, name)
01225 {
01226 m_internal_callback_connection =
01227 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01228 }
01229
01230 signal(const std::string& path, const std::string& interface, const std::string& name):
01231 signal_base(path, interface, name)
01232 {
01233 m_internal_callback_connection =
01234 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01235 }
01236
01237 signal(const std::string& interface, const std::string& name, const signal& src) :
01238 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
01239 signal_base(interface, name)
01240 { }
01241
01242 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01243 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(src),
01244 signal_base(path, interface, name)
01245 { }
01246
01247 static pointer create(const std::string& interface, const std::string& name)
01248 {
01249 return pointer( new signal(interface, name) );
01250 }
01251
01252 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01253 {
01254 return pointer( new signal(path, interface, name) );
01255 }
01256
01257 static pointer create(const std::string& interface, const std::string& name, const signal& src)
01258 {
01259 return pointer( new signal(interface, name, src) );
01260 }
01261
01262 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01263 {
01264 return pointer( new signal(path, interface, name, src) );
01265 }
01266
01267 virtual signal_base::pointer clone()
01268 {
01269 return signal_base::pointer( new signal(*this) );
01270 }
01271
01273 virtual std::string introspect(int space_depth=0) const
01274 {
01275 std::ostringstream sout;
01276 std::string spaces;
01277 for (int i=0; i < space_depth; i++ ) spaces += " ";
01278 sout << spaces << "<signal name=\"" << name() << "\">\n";
01279
01280 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01281 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01282 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01283 sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
01284 sout << spaces << "</signal>\n";
01285 return sout.str();
01286 }
01287
01288 virtual std::string arg_name(size_t i) {
01289 if ( i < 4 ) return m_arg_names[i];
01290 return std::string();
01291 }
01292
01293 virtual void set_arg_name(size_t i, const std::string& name) {
01294 if ( i < 4 ) m_arg_names[i] = name;
01295 }
01296
01297 protected:
01298
01299 friend class Interface;
01300
01301 std::string m_arg_names[4];
01302
01303 sigc::connection m_internal_callback_connection;
01304
01305 T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4)
01306 {
01307 DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 << arg4 );
01308 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01309 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01310 *__msg << arg1 << arg2 << arg3 << arg4;
01311 #ifdef DBUS_CXX_DEBUG_ENABLED
01312 bool result = this->handle_dbus_outgoing(__msg);
01313 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01314 #else
01315 this->handle_dbus_outgoing(__msg);
01316 #endif
01317 }
01318
01319 };
01320
01321
01337 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
01338 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
01339 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>, public signal_base
01340 {
01341 public:
01342
01343
01344
01345
01346
01347
01348
01349
01350
01351
01352
01353
01354
01355
01356
01357
01358
01359
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 typedef DBusCxxPointer<signal> pointer;
01443
01444 signal(const std::string& interface, const std::string& name):
01445 signal_base(interface, name)
01446 {
01447 m_internal_callback_connection =
01448 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01449 }
01450
01451 signal(const std::string& path, const std::string& interface, const std::string& name):
01452 signal_base(path, interface, name)
01453 {
01454 m_internal_callback_connection =
01455 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01456 }
01457
01458 signal(const std::string& interface, const std::string& name, const signal& src) :
01459 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
01460 signal_base(interface, name)
01461 { }
01462
01463 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01464 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(src),
01465 signal_base(path, interface, name)
01466 { }
01467
01468 static pointer create(const std::string& interface, const std::string& name)
01469 {
01470 return pointer( new signal(interface, name) );
01471 }
01472
01473 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01474 {
01475 return pointer( new signal(path, interface, name) );
01476 }
01477
01478 static pointer create(const std::string& interface, const std::string& name, const signal& src)
01479 {
01480 return pointer( new signal(interface, name, src) );
01481 }
01482
01483 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01484 {
01485 return pointer( new signal(path, interface, name, src) );
01486 }
01487
01488 virtual signal_base::pointer clone()
01489 {
01490 return signal_base::pointer( new signal(*this) );
01491 }
01492
01494 virtual std::string introspect(int space_depth=0) const
01495 {
01496 std::ostringstream sout;
01497 std::string spaces;
01498 for (int i=0; i < space_depth; i++ ) spaces += " ";
01499 sout << spaces << "<signal name=\"" << name() << "\">\n";
01500
01501 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01502 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01503 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01504 sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
01505 sout << spaces << " <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature<T_arg5>() << "\"/>\n";
01506 sout << spaces << "</signal>\n";
01507 return sout.str();
01508 }
01509
01510 virtual std::string arg_name(size_t i) {
01511 if ( i < 5 ) return m_arg_names[i];
01512 return std::string();
01513 }
01514
01515 virtual void set_arg_name(size_t i, const std::string& name) {
01516 if ( i < 5 ) m_arg_names[i] = name;
01517 }
01518
01519 protected:
01520
01521 friend class Interface;
01522
01523 std::string m_arg_names[5];
01524
01525 sigc::connection m_internal_callback_connection;
01526
01527 T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5)
01528 {
01529 DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 << arg4 << arg5 );
01530 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01531 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01532 *__msg << arg1 << arg2 << arg3 << arg4 << arg5;
01533 #ifdef DBUS_CXX_DEBUG_ENABLED
01534 bool result = this->handle_dbus_outgoing(__msg);
01535 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01536 #else
01537 this->handle_dbus_outgoing(__msg);
01538 #endif
01539 }
01540
01541 };
01542
01543
01559 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
01560 class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
01561 : public sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>, public signal_base
01562 {
01563 public:
01564
01565
01566
01567
01568
01569
01570
01571
01572
01573
01574
01575
01576
01577
01578
01579
01580
01581
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 typedef DBusCxxPointer<signal> pointer;
01666
01667 signal(const std::string& interface, const std::string& name):
01668 signal_base(interface, name)
01669 {
01670 m_internal_callback_connection =
01671 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01672 }
01673
01674 signal(const std::string& path, const std::string& interface, const std::string& name):
01675 signal_base(path, interface, name)
01676 {
01677 m_internal_callback_connection =
01678 this->connect( sigc::mem_fun(*this, &signal::internal_callback) );
01679 }
01680
01681 signal(const std::string& interface, const std::string& name, const signal& src) :
01682 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
01683 signal_base(interface, name)
01684 { }
01685
01686 signal(const std::string& path, const std::string& interface, const std::string& name, const signal& src) :
01687 sigc::signal<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(src),
01688 signal_base(path, interface, name)
01689 { }
01690
01691 static pointer create(const std::string& interface, const std::string& name)
01692 {
01693 return pointer( new signal(interface, name) );
01694 }
01695
01696 static pointer create(const std::string& path, const std::string& interface, const std::string& name)
01697 {
01698 return pointer( new signal(path, interface, name) );
01699 }
01700
01701 static pointer create(const std::string& interface, const std::string& name, const signal& src)
01702 {
01703 return pointer( new signal(interface, name, src) );
01704 }
01705
01706 static pointer create(const std::string& path, const std::string& interface, const std::string& name, const signal& src)
01707 {
01708 return pointer( new signal(path, interface, name, src) );
01709 }
01710
01711 virtual signal_base::pointer clone()
01712 {
01713 return signal_base::pointer( new signal(*this) );
01714 }
01715
01717 virtual std::string introspect(int space_depth=0) const
01718 {
01719 std::ostringstream sout;
01720 std::string spaces;
01721 for (int i=0; i < space_depth; i++ ) spaces += " ";
01722 sout << spaces << "<signal name=\"" << name() << "\">\n";
01723
01724 sout << spaces << " <arg name=\"" << m_arg_names[1-1] << "\" type=\"" << signature<T_arg1>() << "\"/>\n";
01725 sout << spaces << " <arg name=\"" << m_arg_names[2-1] << "\" type=\"" << signature<T_arg2>() << "\"/>\n";
01726 sout << spaces << " <arg name=\"" << m_arg_names[3-1] << "\" type=\"" << signature<T_arg3>() << "\"/>\n";
01727 sout << spaces << " <arg name=\"" << m_arg_names[4-1] << "\" type=\"" << signature<T_arg4>() << "\"/>\n";
01728 sout << spaces << " <arg name=\"" << m_arg_names[5-1] << "\" type=\"" << signature<T_arg5>() << "\"/>\n";
01729 sout << spaces << " <arg name=\"" << m_arg_names[6-1] << "\" type=\"" << signature<T_arg6>() << "\"/>\n";
01730 sout << spaces << "</signal>\n";
01731 return sout.str();
01732 }
01733
01734 virtual std::string arg_name(size_t i) {
01735 if ( i < 6 ) return m_arg_names[i];
01736 return std::string();
01737 }
01738
01739 virtual void set_arg_name(size_t i, const std::string& name) {
01740 if ( i < 6 ) m_arg_names[i] = name;
01741 }
01742
01743 protected:
01744
01745 friend class Interface;
01746
01747 std::string m_arg_names[6];
01748
01749 sigc::connection m_internal_callback_connection;
01750
01751 T_return internal_callback(T_arg1 arg1,T_arg2 arg2,T_arg3 arg3,T_arg4 arg4,T_arg5 arg5,T_arg6 arg6)
01752 {
01753 DBUS_CXX_DEBUG( "signal::internal_callback: " << arg1 << arg2 << arg3 << arg4 << arg5 << arg6 );
01754 SignalMessage::pointer __msg = SignalMessage::create(m_path, m_interface, m_name);
01755 if ( not m_destination.empty() ) __msg->set_destination(m_destination);
01756 *__msg << arg1 << arg2 << arg3 << arg4 << arg5 << arg6;
01757 #ifdef DBUS_CXX_DEBUG_ENABLED
01758 bool result = this->handle_dbus_outgoing(__msg);
01759 DBUS_CXX_DEBUG( "signal::internal_callback: result=" << result );
01760 #else
01761 this->handle_dbus_outgoing(__msg);
01762 #endif
01763 }
01764
01765 };
01766
01767
01768
01769 }
01770
01771 #endif