WebSVN – Kolibri OS – Blame – /contrib/media/updf/include/sigc++/basic_signal.h

Rev	Author	Line No.	Line
4680	right-hear	1	// -- c++ --
		2	/* This is a generated file, do not edit. Generated from ../sigc++/macros/basic_signal.h.m4 */
		3
		4	#ifndef SIGCXX_BASIC_SIGNAL_H
		5	#define SIGCXX_BASIC_SIGNAL_H
		6	#include
		7	#include
		8
		9	// Qt steals a method name.
		10	#ifdef SIGC_QT
		11	#undef emit
		12	#endif
		13
		14	#ifdef emit
		15	#define SIGC_QT
		16	#undef emit
		17	#endif
		18
		19
		20
		21	#ifdef SIGC_CXX_NAMESPACES
		22	namespace SigC
		23	{
		24	#endif
		25
		26	/****************************************************************
		27	***** Signals (build by macros)
		28	****************************************************************/
		29
		30	// common part to all signals
		31	class LIBSIGC_API Signal_
		32	{
		33	private:
		34	Signal_(const Signal_&);
		35
		36	protected:
		37	typedef ScopeList List;
		38
		39	struct LIBSIGC_API Impl
		40	{
		41	typedef ScopeList List;
		42	List incoming_;
		43	List outgoing_;
		44	Impl();
		45	~Impl();
		46	};
		47
		48	Impl *impl;
		49
		50	SlotData* in_connect();
		51	SlotData* out_connect(SlotData *s);
		52
		53	Signal_();
		54	~Signal_();
		55
		56	public:
		57	bool empty() const;
		58	void clear();
		59	};
		60
		61
		62	/****************************************************************
		63	***** Signal 0
		64	****************************************************************/
		65
		66	template >
		67	class Signal0:public Signal_
		68	{
		69	public:
		70	typedef Slot0 InSlotType;
		71	typedef Slot0 OutSlotType;
		72
		73	private:
		74	#ifdef SIGC_CXX_PARTIAL_SPEC
		75	typedef typename Marsh::OutType SType;
		76	typedef R RType;
		77	#else
		78	typedef Trait::type SType;
		79	typedef Trait::type RType;
		80	#endif
		81	typedef typename InSlotType::Callback Callback;
		82	typedef Signal0 Self;
		83	typedef CallDataObj2 CallData;
		84
		85	static SType callback(void* d)
		86	{
		87	CallData* data=(CallData*)d;
		88	return data->obj->emit();
		89	}
		90
		91	public:
		92	OutSlotType slot()
		93	{
		94	SlotData* tmp=in_connect();
		95	CallData &data=reinterpret_cast(tmp->data_);
		96	data.callback=(typename OutSlotType::Func)callback;
		97	data.obj=this;
		98	return tmp;
		99	}
		100
		101	Connection connect(const InSlotType &s)
		102	{
		103	return out_connect(s.data());
		104	}
		105
		106	SType emit();
		107	SType operator()()
		108	{return emit();}
		109
		110	Signal0() {}
		111	Signal0(const InSlotType &s) {connect(s);}
		112	~Signal0() {}
		113	};
		114
		115
		116	// emit
		117	template
		118	typename Signal0::SType Signal0::
		119	emit()
		120	{
		121	if (!impl\|\|impl->outgoing_.empty()) return Marsh::default_value();
		122	List &out=impl->outgoing_;
		123	Marsh rc;
		124	SlotData *data;
		125	List::Iterator i=out.begin();
		126	while (i!=out.end())
		127	{
		128	data=((SlotDependent*)(i.node()))->parent();
		129	++i;
		130	Callback& s=(Callback&)(data->callback());
		131	if (rc.marshal(s.call())) return rc.value();
		132	}
		133	return rc.value();
		134	}
		135
		136	#ifdef SIGC_CXX_PARTIAL_SPEC
		137	template
		138	class Signal0
		139	:public Signal_
		140	{
		141	public:
		142	typedef Slot0 InSlotType;
		143	typedef Slot0 OutSlotType;
		144	private:
		145	typedef InSlotType::Callback Callback;
		146	typedef Signal0 Self;
		147	typedef CallDataObj2 CallData;
		148
		149	static void callback(void* d)
		150	{
		151	CallData* data=(CallData*)d;
		152	data->obj->emit();
		153	}
		154
		155	public:
		156	OutSlotType slot()
		157	{
		158	SlotData* tmp=in_connect();
		159	CallData& data=reinterpret_cast(tmp->data_);
		160	data.callback=callback;
		161	data.obj=this;
		162	return tmp;
		163	}
		164
		165	Connection connect(const InSlotType &s)
		166	{
		167	return out_connect(s.data());
		168	}
		169
		170	void emit();
		171	void operator()()
		172	{emit();}
		173
		174	Signal0() {}
		175	Signal0(const InSlotType &s) {connect(s);}
		176	~Signal0() {}
		177	};
		178
		179
		180	// emit
		181	template
		182	void Signal0::
		183	emit()
		184	{
		185	if (!impl\|\|impl->outgoing_.empty()) return;
		186	List &out=impl->outgoing_;
		187	SlotData *data;
		188	List::Iterator i=out.begin();
		189	while (i!=out.end())
		190	{
		191	data=((SlotDependent*)(i.node()))->parent();
		192	++i;
		193	Callback& s=(Callback&)(data->callback());
		194	s.call();
		195	}
		196	}
		197
		198	#endif
		199
		200
		201	/****************************************************************
		202	***** Signal 1
		203	****************************************************************/
		204
		205	template >
		206	class Signal1:public Signal_
		207	{
		208	public:
		209	typedef Slot1 InSlotType;
		210	typedef Slot1 OutSlotType;
		211
		212	private:
		213	#ifdef SIGC_CXX_PARTIAL_SPEC
		214	typedef typename Marsh::OutType SType;
		215	typedef R RType;
		216	#else
		217	typedef Trait::type SType;
		218	typedef Trait::type RType;
		219	#endif
		220	typedef typename InSlotType::Callback Callback;
		221	typedef Signal1 Self;
		222	typedef CallDataObj2 CallData;
		223
		224	static SType callback(void* d,P1 p1)
		225	{
		226	CallData* data=(CallData*)d;
		227	return data->obj->emit(p1);
		228	}
		229
		230	public:
		231	OutSlotType slot()
		232	{
		233	SlotData* tmp=in_connect();
		234	CallData &data=reinterpret_cast(tmp->data_);
		235	data.callback=(typename OutSlotType::Func)callback;
		236	data.obj=this;
		237	return tmp;
		238	}
		239
		240	Connection connect(const InSlotType &s)
		241	{
		242	return out_connect(s.data());
		243	}
		244
		245	SType emit(typename Trait::ref p1);
		246	SType operator()(typename Trait::ref p1)
		247	{return emit(p1);}
		248
		249	Signal1() {}
		250	Signal1(const InSlotType &s) {connect(s);}
		251	~Signal1() {}
		252	};
		253
		254
		255	// emit
		256	template
		257	typename Signal1::SType Signal1::
		258	emit(typename Trait::ref p1)
		259	{
		260	if (!impl\|\|impl->outgoing_.empty()) return Marsh::default_value();
		261	List &out=impl->outgoing_;
		262	Marsh rc;
		263	SlotData *data;
		264	List::Iterator i=out.begin();
		265	while (i!=out.end())
		266	{
		267	data=((SlotDependent*)(i.node()))->parent();
		268	++i;
		269	Callback& s=(Callback&)(data->callback());
		270	if (rc.marshal(s.call(p1))) return rc.value();
		271	}
		272	return rc.value();
		273	}
		274
		275	#ifdef SIGC_CXX_PARTIAL_SPEC
		276	template
		277	class Signal1
		278	:public Signal_
		279	{
		280	public:
		281	typedef Slot1 InSlotType;
		282	typedef Slot1 OutSlotType;
		283	private:
		284	typedef typename InSlotType::Callback Callback;
		285	typedef Signal1 Self;
		286	typedef CallDataObj2 CallData;
		287
		288	static void callback(void* d,P1 p1)
		289	{
		290	CallData* data=(CallData*)d;
		291	data->obj->emit(p1);
		292	}
		293
		294	public:
		295	OutSlotType slot()
		296	{
		297	SlotData* tmp=in_connect();
		298	CallData& data=reinterpret_cast(tmp->data_);
		299	data.callback=callback;
		300	data.obj=this;
		301	return tmp;
		302	}
		303
		304	Connection connect(const InSlotType &s)
		305	{
		306	return out_connect(s.data());
		307	}
		308
		309	void emit(typename Trait::ref p1);
		310	void operator()(typename Trait::ref p1)
		311	{emit(p1);}
		312
		313	Signal1() {}
		314	Signal1(const InSlotType &s) {connect(s);}
		315	~Signal1() {}
		316	};
		317
		318
		319	// emit
		320	template
		321	void Signal1::
		322	emit(typename Trait::ref p1)
		323	{
		324	if (!impl\|\|impl->outgoing_.empty()) return;
		325	List &out=impl->outgoing_;
		326	SlotData *data;
		327	List::Iterator i=out.begin();
		328	while (i!=out.end())
		329	{
		330	data=((SlotDependent*)(i.node()))->parent();
		331	++i;
		332	Callback& s=(Callback&)(data->callback());
		333	s.call(p1);
		334	}
		335	}
		336
		337	#endif
		338
		339
		340	/****************************************************************
		341	***** Signal 2
		342	****************************************************************/
		343
		344	template >
		345	class Signal2:public Signal_
		346	{
		347	public:
		348	typedef Slot2 InSlotType;
		349	typedef Slot2 OutSlotType;
		350
		351	private:
		352	#ifdef SIGC_CXX_PARTIAL_SPEC
		353	typedef typename Marsh::OutType SType;
		354	typedef R RType;
		355	#else
		356	typedef Trait::type SType;
		357	typedef Trait::type RType;
		358	#endif
		359	typedef typename InSlotType::Callback Callback;
		360	typedef Signal2 Self;
		361	typedef CallDataObj2 CallData;
		362
		363	static SType callback(void* d,P1 p1,P2 p2)
		364	{
		365	CallData* data=(CallData*)d;
		366	return data->obj->emit(p1,p2);
		367	}
		368
		369	public:
		370	OutSlotType slot()
		371	{
		372	SlotData* tmp=in_connect();
		373	CallData &data=reinterpret_cast(tmp->data_);
		374	data.callback=(typename OutSlotType::Func)callback;
		375	data.obj=this;
		376	return tmp;
		377	}
		378
		379	Connection connect(const InSlotType &s)
		380	{
		381	return out_connect(s.data());
		382	}
		383
		384	SType emit(typename Trait::ref p1,typename Trait::ref p2);
		385	SType operator()(typename Trait::ref p1,typename Trait::ref p2)
		386	{return emit(p1,p2);}
		387
		388	Signal2() {}
		389	Signal2(const InSlotType &s) {connect(s);}
		390	~Signal2() {}
		391	};
		392
		393
		394	// emit
		395	template
		396	typename Signal2::SType Signal2::
		397	emit(typename Trait::ref p1,typename Trait::ref p2)
		398	{
		399	if (!impl\|\|impl->outgoing_.empty()) return Marsh::default_value();
		400	List &out=impl->outgoing_;
		401	Marsh rc;
		402	SlotData *data;
		403	List::Iterator i=out.begin();
		404	while (i!=out.end())
		405	{
		406	data=((SlotDependent*)(i.node()))->parent();
		407	++i;
		408	Callback& s=(Callback&)(data->callback());
		409	if (rc.marshal(s.call(p1,p2))) return rc.value();
		410	}
		411	return rc.value();
		412	}
		413
		414	#ifdef SIGC_CXX_PARTIAL_SPEC
		415	template
		416	class Signal2
		417	:public Signal_
		418	{
		419	public:
		420	typedef Slot2 InSlotType;
		421	typedef Slot2 OutSlotType;
		422	private:
		423	typedef typename InSlotType::Callback Callback;
		424	typedef Signal2 Self;
		425	typedef CallDataObj2 CallData;
		426
		427	static void callback(void* d,P1 p1,P2 p2)
		428	{
		429	CallData* data=(CallData*)d;
		430	data->obj->emit(p1,p2);
		431	}
		432
		433	public:
		434	OutSlotType slot()
		435	{
		436	SlotData* tmp=in_connect();
		437	CallData& data=reinterpret_cast(tmp->data_);
		438	data.callback=callback;
		439	data.obj=this;
		440	return tmp;
		441	}
		442
		443	Connection connect(const InSlotType &s)
		444	{
		445	return out_connect(s.data());
		446	}
		447
		448	void emit(typename Trait::ref p1,typename Trait::ref p2);
		449	void operator()(typename Trait::ref p1,typename Trait::ref p2)
		450	{emit(p1,p2);}
		451
		452	Signal2() {}
		453	Signal2(const InSlotType &s) {connect(s);}
		454	~Signal2() {}
		455	};
		456
		457
		458	// emit
		459	template
		460	void Signal2::
		461	emit(typename Trait::ref p1,typename Trait::ref p2)
		462	{
		463	if (!impl\|\|impl->outgoing_.empty()) return;
		464	List &out=impl->outgoing_;
		465	SlotData *data;
		466	List::Iterator i=out.begin();
		467	while (i!=out.end())
		468	{
		469	data=((SlotDependent*)(i.node()))->parent();
		470	++i;
		471	Callback& s=(Callback&)(data->callback());
		472	s.call(p1,p2);
		473	}
		474	}
		475
		476	#endif
		477
		478
		479	/****************************************************************
		480	***** Signal 3
		481	****************************************************************/
		482
		483	template >
		484	class Signal3:public Signal_
		485	{
		486	public:
		487	typedef Slot3 InSlotType;
		488	typedef Slot3 OutSlotType;
		489
		490	private:
		491	#ifdef SIGC_CXX_PARTIAL_SPEC
		492	typedef typename Marsh::OutType SType;
		493	typedef R RType;
		494	#else
		495	typedef Trait::type SType;
		496	typedef Trait::type RType;
		497	#endif
		498	typedef typename InSlotType::Callback Callback;
		499	typedef Signal3 Self;
		500	typedef CallDataObj2 CallData;
		501
		502	static SType callback(void* d,P1 p1,P2 p2,P3 p3)
		503	{
		504	CallData* data=(CallData*)d;
		505	return data->obj->emit(p1,p2,p3);
		506	}
		507
		508	public:
		509	OutSlotType slot()
		510	{
		511	SlotData* tmp=in_connect();
		512	CallData &data=reinterpret_cast(tmp->data_);
		513	data.callback=(typename OutSlotType::Func)callback;
		514	data.obj=this;
		515	return tmp;
		516	}
		517
		518	Connection connect(const InSlotType &s)
		519	{
		520	return out_connect(s.data());
		521	}
		522
		523	SType emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3);
		524	SType operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3)
		525	{return emit(p1,p2,p3);}
		526
		527	Signal3() {}
		528	Signal3(const InSlotType &s) {connect(s);}
		529	~Signal3() {}
		530	};
		531
		532
		533	// emit
		534	template
		535	typename Signal3::SType Signal3::
		536	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3)
		537	{
		538	if (!impl\|\|impl->outgoing_.empty()) return Marsh::default_value();
		539	List &out=impl->outgoing_;
		540	Marsh rc;
		541	SlotData *data;
		542	List::Iterator i=out.begin();
		543	while (i!=out.end())
		544	{
		545	data=((SlotDependent*)(i.node()))->parent();
		546	++i;
		547	Callback& s=(Callback&)(data->callback());
		548	if (rc.marshal(s.call(p1,p2,p3))) return rc.value();
		549	}
		550	return rc.value();
		551	}
		552
		553	#ifdef SIGC_CXX_PARTIAL_SPEC
		554	template
		555	class Signal3
		556	:public Signal_
		557	{
		558	public:
		559	typedef Slot3 InSlotType;
		560	typedef Slot3 OutSlotType;
		561	private:
		562	typedef typename InSlotType::Callback Callback;
		563	typedef Signal3 Self;
		564	typedef CallDataObj2 CallData;
		565
		566	static void callback(void* d,P1 p1,P2 p2,P3 p3)
		567	{
		568	CallData* data=(CallData*)d;
		569	data->obj->emit(p1,p2,p3);
		570	}
		571
		572	public:
		573	OutSlotType slot()
		574	{
		575	SlotData* tmp=in_connect();
		576	CallData& data=reinterpret_cast(tmp->data_);
		577	data.callback=callback;
		578	data.obj=this;
		579	return tmp;
		580	}
		581
		582	Connection connect(const InSlotType &s)
		583	{
		584	return out_connect(s.data());
		585	}
		586
		587	void emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3);
		588	void operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3)
		589	{emit(p1,p2,p3);}
		590
		591	Signal3() {}
		592	Signal3(const InSlotType &s) {connect(s);}
		593	~Signal3() {}
		594	};
		595
		596
		597	// emit
		598	template
		599	void Signal3::
		600	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3)
		601	{
		602	if (!impl\|\|impl->outgoing_.empty()) return;
		603	List &out=impl->outgoing_;
		604	SlotData *data;
		605	List::Iterator i=out.begin();
		606	while (i!=out.end())
		607	{
		608	data=((SlotDependent*)(i.node()))->parent();
		609	++i;
		610	Callback& s=(Callback&)(data->callback());
		611	s.call(p1,p2,p3);
		612	}
		613	}
		614
		615	#endif
		616
		617
		618	/****************************************************************
		619	***** Signal 4
		620	****************************************************************/
		621
		622	template >
		623	class Signal4:public Signal_
		624	{
		625	public:
		626	typedef Slot4 InSlotType;
		627	typedef Slot4 OutSlotType;
		628
		629	private:
		630	#ifdef SIGC_CXX_PARTIAL_SPEC
		631	typedef typename Marsh::OutType SType;
		632	typedef R RType;
		633	#else
		634	typedef Trait::type SType;
		635	typedef Trait::type RType;
		636	#endif
		637	typedef typename InSlotType::Callback Callback;
		638	typedef Signal4 Self;
		639	typedef CallDataObj2 CallData;
		640
		641	static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
		642	{
		643	CallData* data=(CallData*)d;
		644	return data->obj->emit(p1,p2,p3,p4);
		645	}
		646
		647	public:
		648	OutSlotType slot()
		649	{
		650	SlotData* tmp=in_connect();
		651	CallData &data=reinterpret_cast(tmp->data_);
		652	data.callback=(typename OutSlotType::Func)callback;
		653	data.obj=this;
		654	return tmp;
		655	}
		656
		657	Connection connect(const InSlotType &s)
		658	{
		659	return out_connect(s.data());
		660	}
		661
		662	SType emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4);
		663	SType operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4)
		664	{return emit(p1,p2,p3,p4);}
		665
		666	Signal4() {}
		667	Signal4(const InSlotType &s) {connect(s);}
		668	~Signal4() {}
		669	};
		670
		671
		672	// emit
		673	template
		674	typename Signal4::SType Signal4::
		675	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4)
		676	{
		677	if (!impl\|\|impl->outgoing_.empty()) return Marsh::default_value();
		678	List &out=impl->outgoing_;
		679	Marsh rc;
		680	SlotData *data;
		681	List::Iterator i=out.begin();
		682	while (i!=out.end())
		683	{
		684	data=((SlotDependent*)(i.node()))->parent();
		685	++i;
		686	Callback& s=(Callback&)(data->callback());
		687	if (rc.marshal(s.call(p1,p2,p3,p4))) return rc.value();
		688	}
		689	return rc.value();
		690	}
		691
		692	#ifdef SIGC_CXX_PARTIAL_SPEC
		693	template
		694	class Signal4
		695	:public Signal_
		696	{
		697	public:
		698	typedef Slot4 InSlotType;
		699	typedef Slot4 OutSlotType;
		700	private:
		701	typedef typename InSlotType::Callback Callback;
		702	typedef Signal4 Self;
		703	typedef CallDataObj2 CallData;
		704
		705	static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
		706	{
		707	CallData* data=(CallData*)d;
		708	data->obj->emit(p1,p2,p3,p4);
		709	}
		710
		711	public:
		712	OutSlotType slot()
		713	{
		714	SlotData* tmp=in_connect();
		715	CallData& data=reinterpret_cast(tmp->data_);
		716	data.callback=callback;
		717	data.obj=this;
		718	return tmp;
		719	}
		720
		721	Connection connect(const InSlotType &s)
		722	{
		723	return out_connect(s.data());
		724	}
		725
		726	void emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4);
		727	void operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4)
		728	{emit(p1,p2,p3,p4);}
		729
		730	Signal4() {}
		731	Signal4(const InSlotType &s) {connect(s);}
		732	~Signal4() {}
		733	};
		734
		735
		736	// emit
		737	template
		738	void Signal4::
		739	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4)
		740	{
		741	if (!impl\|\|impl->outgoing_.empty()) return;
		742	List &out=impl->outgoing_;
		743	SlotData *data;
		744	List::Iterator i=out.begin();
		745	while (i!=out.end())
		746	{
		747	data=((SlotDependent*)(i.node()))->parent();
		748	++i;
		749	Callback& s=(Callback&)(data->callback());
		750	s.call(p1,p2,p3,p4);
		751	}
		752	}
		753
		754	#endif
		755
		756
		757	/****************************************************************
		758	***** Signal 5
		759	****************************************************************/
		760
		761	template >
		762	class Signal5:public Signal_
		763	{
		764	public:
		765	typedef Slot5 InSlotType;
		766	typedef Slot5 OutSlotType;
		767
		768	private:
		769	#ifdef SIGC_CXX_PARTIAL_SPEC
		770	typedef typename Marsh::OutType SType;
		771	typedef R RType;
		772	#else
		773	typedef Trait::type SType;
		774	typedef Trait::type RType;
		775	#endif
		776	typedef typename InSlotType::Callback Callback;
		777	typedef Signal5 Self;
		778	typedef CallDataObj2 CallData;
		779
		780	static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
		781	{
		782	CallData* data=(CallData*)d;
		783	return data->obj->emit(p1,p2,p3,p4,p5);
		784	}
		785
		786	public:
		787	OutSlotType slot()
		788	{
		789	SlotData* tmp=in_connect();
		790	CallData &data=reinterpret_cast(tmp->data_);
		791	data.callback=(typename OutSlotType::Func)callback;
		792	data.obj=this;
		793	return tmp;
		794	}
		795
		796	Connection connect(const InSlotType &s)
		797	{
		798	return out_connect(s.data());
		799	}
		800
		801	SType emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5);
		802	SType operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5)
		803	{return emit(p1,p2,p3,p4,p5);}
		804
		805	Signal5() {}
		806	Signal5(const InSlotType &s) {connect(s);}
		807	~Signal5() {}
		808	};
		809
		810
		811	// emit
		812	template
		813	typename Signal5::SType Signal5::
		814	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5)
		815	{
		816	if (!impl\|\|impl->outgoing_.empty()) return Marsh::default_value();
		817	List &out=impl->outgoing_;
		818	Marsh rc;
		819	SlotData *data;
		820	List::Iterator i=out.begin();
		821	while (i!=out.end())
		822	{
		823	data=((SlotDependent*)(i.node()))->parent();
		824	++i;
		825	Callback& s=(Callback&)(data->callback());
		826	if (rc.marshal(s.call(p1,p2,p3,p4,p5))) return rc.value();
		827	}
		828	return rc.value();
		829	}
		830
		831	#ifdef SIGC_CXX_PARTIAL_SPEC
		832	template
		833	class Signal5
		834	:public Signal_
		835	{
		836	public:
		837	typedef Slot5 InSlotType;
		838	typedef Slot5 OutSlotType;
		839	private:
		840	typedef typename InSlotType::Callback Callback;
		841	typedef Signal5 Self;
		842	typedef CallDataObj2 CallData;
		843
		844	static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
		845	{
		846	CallData* data=(CallData*)d;
		847	data->obj->emit(p1,p2,p3,p4,p5);
		848	}
		849
		850	public:
		851	OutSlotType slot()
		852	{
		853	SlotData* tmp=in_connect();
		854	CallData& data=reinterpret_cast(tmp->data_);
		855	data.callback=callback;
		856	data.obj=this;
		857	return tmp;
		858	}
		859
		860	Connection connect(const InSlotType &s)
		861	{
		862	return out_connect(s.data());
		863	}
		864
		865	void emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5);
		866	void operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5)
		867	{emit(p1,p2,p3,p4,p5);}
		868
		869	Signal5() {}
		870	Signal5(const InSlotType &s) {connect(s);}
		871	~Signal5() {}
		872	};
		873
		874
		875	// emit
		876	template
		877	void Signal5::
		878	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5)
		879	{
		880	if (!impl\|\|impl->outgoing_.empty()) return;
		881	List &out=impl->outgoing_;
		882	SlotData *data;
		883	List::Iterator i=out.begin();
		884	while (i!=out.end())
		885	{
		886	data=((SlotDependent*)(i.node()))->parent();
		887	++i;
		888	Callback& s=(Callback&)(data->callback());
		889	s.call(p1,p2,p3,p4,p5);
		890	}
		891	}
		892
		893	#endif
		894
		895
		896	/****************************************************************
		897	***** Signal 6
		898	****************************************************************/
		899
		900	template >
		901	class Signal6:public Signal_
		902	{
		903	public:
		904	typedef Slot6 InSlotType;
		905	typedef Slot6 OutSlotType;
		906
		907	private:
		908	#ifdef SIGC_CXX_PARTIAL_SPEC
		909	typedef typename Marsh::OutType SType;
		910	typedef R RType;
		911	#else
		912	typedef Trait::type SType;
		913	typedef Trait::type RType;
		914	#endif
		915	typedef typename InSlotType::Callback Callback;
		916	typedef Signal6 Self;
		917	typedef CallDataObj2 CallData;
		918
		919	static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
		920	{
		921	CallData* data=(CallData*)d;
		922	return data->obj->emit(p1,p2,p3,p4,p5,p6);
		923	}
		924
		925	public:
		926	OutSlotType slot()
		927	{
		928	SlotData* tmp=in_connect();
		929	CallData &data=reinterpret_cast(tmp->data_);
		930	data.callback=(typename OutSlotType::Func)callback;
		931	data.obj=this;
		932	return tmp;
		933	}
		934
		935	Connection connect(const InSlotType &s)
		936	{
		937	return out_connect(s.data());
		938	}
		939
		940	SType emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6);
		941	SType operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6)
		942	{return emit(p1,p2,p3,p4,p5,p6);}
		943
		944	Signal6() {}
		945	Signal6(const InSlotType &s) {connect(s);}
		946	~Signal6() {}
		947	};
		948
		949
		950	// emit
		951	template
		952	typename Signal6::SType Signal6::
		953	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6)
		954	{
		955	if (!impl\|\|impl->outgoing_.empty()) return Marsh::default_value();
		956	List &out=impl->outgoing_;
		957	Marsh rc;
		958	SlotData *data;
		959	List::Iterator i=out.begin();
		960	while (i!=out.end())
		961	{
		962	data=((SlotDependent*)(i.node()))->parent();
		963	++i;
		964	Callback& s=(Callback&)(data->callback());
		965	if (rc.marshal(s.call(p1,p2,p3,p4,p5,p6))) return rc.value();
		966	}
		967	return rc.value();
		968	}
		969
		970	#ifdef SIGC_CXX_PARTIAL_SPEC
		971	template
		972	class Signal6
		973	:public Signal_
		974	{
		975	public:
		976	typedef Slot6 InSlotType;
		977	typedef Slot6 OutSlotType;
		978	private:
		979	typedef typename InSlotType::Callback Callback;
		980	typedef Signal6 Self;
		981	typedef CallDataObj2 CallData;
		982
		983	static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
		984	{
		985	CallData* data=(CallData*)d;
		986	data->obj->emit(p1,p2,p3,p4,p5,p6);
		987	}
		988
		989	public:
		990	OutSlotType slot()
		991	{
		992	SlotData* tmp=in_connect();
		993	CallData& data=reinterpret_cast(tmp->data_);
		994	data.callback=callback;
		995	data.obj=this;
		996	return tmp;
		997	}
		998
		999	Connection connect(const InSlotType &s)
		1000	{
		1001	return out_connect(s.data());
		1002	}
		1003
		1004	void emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6);
		1005	void operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6)
		1006	{emit(p1,p2,p3,p4,p5,p6);}
		1007
		1008	Signal6() {}
		1009	Signal6(const InSlotType &s) {connect(s);}
		1010	~Signal6() {}
		1011	};
		1012
		1013
		1014	// emit
		1015	template
		1016	void Signal6::
		1017	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6)
		1018	{
		1019	if (!impl\|\|impl->outgoing_.empty()) return;
		1020	List &out=impl->outgoing_;
		1021	SlotData *data;
		1022	List::Iterator i=out.begin();
		1023	while (i!=out.end())
		1024	{
		1025	data=((SlotDependent*)(i.node()))->parent();
		1026	++i;
		1027	Callback& s=(Callback&)(data->callback());
		1028	s.call(p1,p2,p3,p4,p5,p6);
		1029	}
		1030	}
		1031
		1032	#endif
		1033
		1034
		1035	/****************************************************************
		1036	***** Signal 7
		1037	****************************************************************/
		1038
		1039	template >
		1040	class Signal7:public Signal_
		1041	{
		1042	public:
		1043	typedef Slot7 InSlotType;
		1044	typedef Slot7 OutSlotType;
		1045
		1046	private:
		1047	#ifdef SIGC_CXX_PARTIAL_SPEC
		1048	typedef typename Marsh::OutType SType;
		1049	typedef R RType;
		1050	#else
		1051	typedef Trait::type SType;
		1052	typedef Trait::type RType;
		1053	#endif
		1054	typedef typename InSlotType::Callback Callback;
		1055	typedef Signal7 Self;
		1056	typedef CallDataObj2 CallData;
		1057
		1058	static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
		1059	{
		1060	CallData* data=(CallData*)d;
		1061	return data->obj->emit(p1,p2,p3,p4,p5,p6,p7);
		1062	}
		1063
		1064	public:
		1065	OutSlotType slot()
		1066	{
		1067	SlotData* tmp=in_connect();
		1068	CallData &data=reinterpret_cast(tmp->data_);
		1069	data.callback=(typename OutSlotType::Func)callback;
		1070	data.obj=this;
		1071	return tmp;
		1072	}
		1073
		1074	Connection connect(const InSlotType &s)
		1075	{
		1076	return out_connect(s.data());
		1077	}
		1078
		1079	SType emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6,typename Trait::ref p7);
		1080	SType operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6,typename Trait::ref p7)
		1081	{return emit(p1,p2,p3,p4,p5,p6,p7);}
		1082
		1083	Signal7() {}
		1084	Signal7(const InSlotType &s) {connect(s);}
		1085	~Signal7() {}
		1086	};
		1087
		1088
		1089	// emit
		1090	template
		1091	typename Signal7::SType Signal7::
		1092	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6,typename Trait::ref p7)
		1093	{
		1094	if (!impl\|\|impl->outgoing_.empty()) return Marsh::default_value();
		1095	List &out=impl->outgoing_;
		1096	Marsh rc;
		1097	SlotData *data;
		1098	List::Iterator i=out.begin();
		1099	while (i!=out.end())
		1100	{
		1101	data=((SlotDependent*)(i.node()))->parent();
		1102	++i;
		1103	Callback& s=(Callback&)(data->callback());
		1104	if (rc.marshal(s.call(p1,p2,p3,p4,p5,p6,p7))) return rc.value();
		1105	}
		1106	return rc.value();
		1107	}
		1108
		1109	#ifdef SIGC_CXX_PARTIAL_SPEC
		1110	template
		1111	class Signal7
		1112	:public Signal_
		1113	{
		1114	public:
		1115	typedef Slot7 InSlotType;
		1116	typedef Slot7 OutSlotType;
		1117	private:
		1118	typedef typename InSlotType::Callback Callback;
		1119	typedef Signal7 Self;
		1120	typedef CallDataObj2 CallData;
		1121
		1122	static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
		1123	{
		1124	CallData* data=(CallData*)d;
		1125	data->obj->emit(p1,p2,p3,p4,p5,p6,p7);
		1126	}
		1127
		1128	public:
		1129	OutSlotType slot()
		1130	{
		1131	SlotData* tmp=in_connect();
		1132	CallData& data=reinterpret_cast(tmp->data_);
		1133	data.callback=callback;
		1134	data.obj=this;
		1135	return tmp;
		1136	}
		1137
		1138	Connection connect(const InSlotType &s)
		1139	{
		1140	return out_connect(s.data());
		1141	}
		1142
		1143	void emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6,typename Trait::ref p7);
		1144	void operator()(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6,typename Trait::ref p7)
		1145	{emit(p1,p2,p3,p4,p5,p6,p7);}
		1146
		1147	Signal7() {}
		1148	Signal7(const InSlotType &s) {connect(s);}
		1149	~Signal7() {}
		1150	};
		1151
		1152
		1153	// emit
		1154	template
		1155	void Signal7::
		1156	emit(typename Trait::ref p1,typename Trait::ref p2,typename Trait::ref p3,typename Trait::ref p4,typename Trait::ref p5,typename Trait::ref p6,typename Trait::ref p7)
		1157	{
		1158	if (!impl\|\|impl->outgoing_.empty()) return;
		1159	List &out=impl->outgoing_;
		1160	SlotData *data;
		1161	List::Iterator i=out.begin();
		1162	while (i!=out.end())
		1163	{
		1164	data=((SlotDependent*)(i.node()))->parent();
		1165	++i;
		1166	Callback& s=(Callback&)(data->callback());
		1167	s.call(p1,p2,p3,p4,p5,p6,p7);
		1168	}
		1169	}
		1170
		1171	#endif
		1172
		1173
		1174
		1175	#ifdef SIGC_CXX_NAMESPACES
		1176	} // namespace
		1177	#endif
		1178
		1179	#ifdef SIGC_QT
		1180	#define emit
		1181	#endif
		1182
		1183
		1184	#endif // SIGCXX_BASIC_SIGNAL_H
		1185

Subversion Repositories Kolibri OS

(root)/contrib/media/updf/include/sigc++/basic_signal.h – Rev 5507