Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/input/src/cpptcl/details/callbacks_v.h @ 1465

Last change on this file since 1465 was 1214, checked in by landauf, 17 years ago

merged console-branch back to trunk.
IMPORTANT: update your media directory!

you need TCL to compile. TCL is available here: ​http://www.tcl.tk/
another option is to check out ​https://svn.orxonox.net/ogre/tcl8.5.2/ and compile it by yourself. makefiles are in the 'macosx', 'unix' and 'win' subfolders.
FindTCL.cmake searches in the usual locations and in ../libs/tcl8.5.2/

the orxonox console can be activated with numpad-enter. whatever you enter will be parsed by TCL. if TCL doesn't know a command, it gets executed by orxonox.

simple tcl commands are: "puts text" to write "text" into the console, "expr 1+1" to calculate the result of the given expression. just try it by yourself with "puts [expr 1+1]".
[x] means: evaluate x and use the returnvalue as an argument. in this case the returned value is "2" and the resulting command therefore "puts 2".

you can combine orxonox and tcl commands. a simple orxonox command is "log text" that writes text into the console and the logfile. test it with "log [expr 1+1]" to write "2" into all output channels of orxonox. something more advanced: "log [clock seconds]" writes the seconds since 1970 into the logfile. feel free to combine both: "log [clock seconds]: 1+1 is [expr 1+1]"

TCL uses variables. to set a new variable, use "set varname value". you can use the variable wherever you want with $varname. with this we can make the above command a bit more elegant:
set myexpression 1+1
log [clock seconds]: $myexpression is [expr $myexpression]

read more about tcl in the wiki: ​http://wiki.tcl.tk/
File size: 8.2 KB
Line 
1//
2// Copyright (C) 2004-2006, Maciej Sobczak
3//
4// Permission to copy, use, modify, sell and distribute this software
5// is granted provided this copyright notice appears in all copies.
6// This software is provided "as is" without express or implied
7// warranty, and with no claim as to its suitability for any purpose.
8//
9
10// Note: this file is not supposed to be a stand-alone header
11
12
13template <typename R>
14class callback1<R, object const &> : public callback_base
15{
16     typedef object const & T1;
17     typedef R (*functor_type)(T1);
18     enum { var_start = 1 };
19     
20public:
21     callback1(functor_type f) : f_(f) {}
22     
23     virtual void invoke(Tcl_Interp *interp,
24          int objc, Tcl_Obj * CONST objv[],
25          policies const &pol)
26     {
27          object t1 = get_var_params(interp, objc, objv, var_start, pol);
28          dispatch<R>::template do_dispatch<T1>(interp, f_,
29               t1);
30     }
31
32private:
33     functor_type f_;
34};
35
36template <typename R, typename T1>
37class callback2<R, T1, object const &> : public callback_base
38{
39     typedef object const & T2;
40     typedef R (*functor_type)(T1, T2);
41     enum { var_start = 2 };
42     
43public:
44     callback2(functor_type f) : f_(f) {}
45     
46     virtual void invoke(Tcl_Interp *interp,
47          int objc, Tcl_Obj * CONST objv[],
48          policies const &pol)
49     {
50          object t2 = get_var_params(interp, objc, objv, var_start, pol);
51          dispatch<R>::template do_dispatch<T1, T2>(interp, f_,
52               tcl_cast<T1>::from(interp, objv[1]),
53               t2);
54     }
55
56private:
57     functor_type f_;
58};
59
60template <typename R, typename T1, typename T2>
61class callback3<R, T1, T2, object const &> : public callback_base
62{
63     typedef object const & T3;
64     typedef R (*functor_type)(T1, T2, T3);
65     enum { var_start = 3 };
66     
67public:
68     callback3(functor_type f) : f_(f) {}
69     
70     virtual void invoke(Tcl_Interp *interp,
71          int objc, Tcl_Obj * CONST objv[],
72          policies const &pol)
73     {
74          object t3 = get_var_params(interp, objc, objv, var_start, pol);
75          dispatch<R>::template do_dispatch<T1, T2, T3>(interp, f_,
76               tcl_cast<T1>::from(interp, objv[1]),
77               tcl_cast<T2>::from(interp, objv[2]),
78               t3);
79     }
80
81private:
82     functor_type f_;
83};
84
85template <typename R, typename T1, typename T2, typename T3>
86class callback4<R, T1, T2, T3, object const &> : public callback_base
87{
88     typedef object const & T4;
89     typedef R (*functor_type)(T1, T2, T3, T4);
90     enum { var_start = 4 };
91     
92public:
93     callback4(functor_type f) : f_(f) {}
94     
95     virtual void invoke(Tcl_Interp *interp,
96          int objc, Tcl_Obj * CONST objv[],
97          policies const &pol)
98     {
99          object t4 = get_var_params(interp, objc, objv, var_start, pol);
100          dispatch<R>::template do_dispatch<T1, T2, T3, T4>(interp, f_,
101               tcl_cast<T1>::from(interp, objv[1]),
102               tcl_cast<T2>::from(interp, objv[2]),
103               tcl_cast<T3>::from(interp, objv[3]),
104               t4);
105     }
106
107private:
108     functor_type f_;
109};
110
111template <typename R, typename T1, typename T2, typename T3, typename T4>
112class callback5<R, T1, T2, T3, T4, object const &> : public callback_base
113{
114     typedef object const & T5;
115     typedef R (*functor_type)(T1, T2, T3, T4, T5);
116     enum { var_start = 5 };
117     
118public:
119     callback5(functor_type f) : f_(f) {}
120     
121     virtual void invoke(Tcl_Interp *interp,
122          int objc, Tcl_Obj * CONST objv[],
123          policies const &pol)
124     {
125          object t5 = get_var_params(interp, objc, objv, var_start, pol);
126          dispatch<R>::template do_dispatch<T1, T2, T3, T4, T5>(
127               interp, f_,
128               tcl_cast<T1>::from(interp, objv[1]),
129               tcl_cast<T2>::from(interp, objv[2]),
130               tcl_cast<T3>::from(interp, objv[3]),
131               tcl_cast<T4>::from(interp, objv[4]),
132               t5);
133     }
134
135private:
136     functor_type f_;
137};
138
139template <typename R, typename T1, typename T2, typename T3, typename T4,
140     typename T5>
141class callback6<R, T1, T2, T3, T4, T5, object const &> : public callback_base
142{
143     typedef object const & T6;
144     typedef R (*functor_type)(T1, T2, T3, T4, T5, T6);
145     enum { var_start = 6 };
146     
147public:
148     callback6(functor_type f) : f_(f) {}
149     
150     virtual void invoke(Tcl_Interp *interp,
151          int objc, Tcl_Obj * CONST objv[],
152          policies const &pol)
153     {
154          object t6 = get_var_params(interp, objc, objv, var_start, pol);
155          dispatch<R>::template do_dispatch<T1, T2, T3, T4, T5, T6>(
156               interp, f_,
157               tcl_cast<T1>::from(interp, objv[1]),
158               tcl_cast<T2>::from(interp, objv[2]),
159               tcl_cast<T3>::from(interp, objv[3]),
160               tcl_cast<T4>::from(interp, objv[4]),
161               tcl_cast<T5>::from(interp, objv[5]),
162               t6);
163     }
164
165private:
166     functor_type f_;
167};
168
169template <typename R, typename T1, typename T2, typename T3, typename T4,
170     typename T5, typename T6>
171class callback7<R, T1, T2, T3, T4, T5, T6, object const &>
172     : public callback_base
173{
174     typedef object const & T7;
175     typedef R (*functor_type)(T1, T2, T3, T4, T5, T6, T7);
176     enum { var_start = 7 };
177     
178public:
179     callback7(functor_type f) : f_(f) {}
180     
181     virtual void invoke(Tcl_Interp *interp,
182          int objc, Tcl_Obj * CONST objv[],
183          policies const &pol)
184     {
185          object t7 = get_var_params(interp, objc, objv, var_start, pol);
186          dispatch<R>::template do_dispatch<T1, T2, T3, T4, T5, T6, T7>(
187               interp, f_,
188               tcl_cast<T1>::from(interp, objv[1]),
189               tcl_cast<T2>::from(interp, objv[2]),
190               tcl_cast<T3>::from(interp, objv[3]),
191               tcl_cast<T4>::from(interp, objv[4]),
192               tcl_cast<T5>::from(interp, objv[5]),
193               tcl_cast<T6>::from(interp, objv[6]),
194               t7);
195     }
196
197private:
198     functor_type f_;
199};
200
201template <typename R, typename T1, typename T2, typename T3, typename T4,
202     typename T5, typename T6, typename T7>
203class callback8<R, T1, T2, T3, T4, T5, T6, T7, object const &>
204     : public callback_base
205{
206     typedef object const & T8;
207     typedef R (*functor_type)(T1, T2, T3, T4, T5, T6, T7, T8);
208     enum { var_start = 8 };
209     
210public:
211     callback8(functor_type f) : f_(f) {}
212     
213     virtual void invoke(Tcl_Interp *interp,
214          int objc, Tcl_Obj * CONST objv[],
215          policies const &pol)
216     {
217          object t8 = get_var_params(interp, objc, objv, var_start, pol);
218          dispatch<R>::template do_dispatch<T1, T2, T3, T4, T5, T6, T7, T8>(
219               interp, f_,
220               tcl_cast<T1>::from(interp, objv[1]),
221               tcl_cast<T2>::from(interp, objv[2]),
222               tcl_cast<T3>::from(interp, objv[3]),
223               tcl_cast<T4>::from(interp, objv[4]),
224               tcl_cast<T5>::from(interp, objv[5]),
225               tcl_cast<T6>::from(interp, objv[6]),
226               tcl_cast<T7>::from(interp, objv[7]),
227               t8);
228     }
229
230private:
231     functor_type f_;
232};
233
234template <typename R, typename T1, typename T2, typename T3, typename T4,
235     typename T5, typename T6, typename T7, typename T8>
236class callback9<R, T1, T2, T3, T4, T5, T6, T7, T8, object const &>
237     : public callback_base
238{
239     typedef object const & T9;
240     typedef R (*functor_type)(T1, T2, T3, T4, T5, T6, T7, T8, T9);
241     enum { var_start = 9 };
242     
243public:
244     callback9(functor_type f) : f_(f) {}
245     
246     virtual void invoke(Tcl_Interp *interp,
247          int objc, Tcl_Obj * CONST objv[],
248          policies const &pol)
249     {
250          object t9 = get_var_params(interp, objc, objv, var_start, pol);
251          dispatch<R>::template do_dispatch<
252               T1, T2, T3, T4, T5, T6, T7, T8, T9>(
253               interp, f_,
254               tcl_cast<T1>::from(interp, objv[1]),
255               tcl_cast<T2>::from(interp, objv[2]),
256               tcl_cast<T3>::from(interp, objv[3]),
257               tcl_cast<T4>::from(interp, objv[4]),
258               tcl_cast<T5>::from(interp, objv[5]),
259               tcl_cast<T6>::from(interp, objv[6]),
260               tcl_cast<T7>::from(interp, objv[7]),
261               tcl_cast<T8>::from(interp, objv[8]),
262               t9);
263     }
264
265private:
266     functor_type f_;
267};
Note: See TracBrowser for help on using the repository browser.