Debian Codegraph @

engine/tolua/tolua.cpp

raw
1 /*
2 ** Lua binding: stratagus
3 ** Generated automatically by tolua++-1.0.92 on Tue Jun 13 09:27:03 2023.
4 */
5
6 #ifndef __cplusplus
7 #include "stdlib.h"
8 #endif
9 #include "string.h"
10
11 #include "tolua++.h"
12
13 /* Exported function */
14 TOLUA_API int tolua_stratagus_open (lua_State* tolua_S);
15
16 #include "stratagus.h"
17 #include "ui.h"
18 #include "minimap.h"
19 #include "player.h"
20 #include "unittype.h"
21 #include "unit.h"
22 #include "video.h"
23 #include "font.h"
24 #include "widgets.h"
25 #include "sound.h"
26 #include "sound_server.h"
27 #include "netconnect.h"
28 #include "map.h"
29 #ifdef _MSC_VER
30 #pragma warning(disable:4800)
31 #endif
32 using std::string;
33 using std::vector;
34 using namespace gcn;
35 #include "network.h"
36 int GetNetworkState() {return (int)NetLocalState;}
37 extern string NetworkMapName;
38 void NetworkGamePrepareGameSettings(void);
39 extern void InitVideo();
40 #include "player.h"
41 #include "editor.h"
42 bool IsReplayGame();
43 void StartMap(const string &str, bool clean = true);
44 void StartReplay(const string &str, bool reveal = false);
45 void StartSavedGame(const string &str);
46 #include "results.h"
47 void StopGame(GameResults result);
48 #include "settings.h"
49 extern int AlliedUnitRecyclingEfficiency[MaxCosts];
50 extern int EnemyUnitRecyclingEfficiency[MaxCosts];
51 #include "patch_type.h"
52 #include "patch.h"
53 #include "patch_manager.h"
54 #include "pathfinder.h"
55 int GetNumOpponents(int player);
56 int GetTimer();
57 void ActionVictory();
58 void ActionDefeat();
59 void ActionDraw();
60 void ActionSetTimer(int cycles, bool increasing);
61 void ActionStartTimer();
62 void ActionStopTimer();
63 void SetTrigger(int trigger);
64 #include "particle.h"
65 extern std::string CliMapName;
66
67 /* function to release collected object via destructor */
68 #ifdef __cplusplus
69
70 static int tolua_collect_MenuScreen (lua_State* tolua_S)
71 {
72 MenuScreen* self = (MenuScreen*) tolua_tousertype(tolua_S,1,0);
73 Mtolua_delete(self);
74 return 0;
75 }
76
77 static int tolua_collect_ImageRadioButton (lua_State* tolua_S)
78 {
79 ImageRadioButton* self = (ImageRadioButton*) tolua_tousertype(tolua_S,1,0);
80 Mtolua_delete(self);
81 return 0;
82 }
83
84 static int tolua_collect_vector_CUIButton_ (lua_State* tolua_S)
85 {
86 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
87 Mtolua_delete(self);
88 return 0;
89 }
90
91 static int tolua_collect_CResourceInfo (lua_State* tolua_S)
92 {
93 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
94 Mtolua_delete(self);
95 return 0;
96 }
97
98 static int tolua_collect_CChunkParticle (lua_State* tolua_S)
99 {
100 CChunkParticle* self = (CChunkParticle*) tolua_tousertype(tolua_S,1,0);
101 Mtolua_delete(self);
102 return 0;
103 }
104
105 static int tolua_collect_vector_CFiller_ (lua_State* tolua_S)
106 {
107 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
108 Mtolua_delete(self);
109 return 0;
110 }
111
112 static int tolua_collect_TextField (lua_State* tolua_S)
113 {
114 TextField* self = (TextField*) tolua_tousertype(tolua_S,1,0);
115 Mtolua_delete(self);
116 return 0;
117 }
118
119 static int tolua_collect_CUIButton (lua_State* tolua_S)
120 {
121 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
122 Mtolua_delete(self);
123 return 0;
124 }
125
126 static int tolua_collect_MultiLineLabel (lua_State* tolua_S)
127 {
128 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
129 Mtolua_delete(self);
130 return 0;
131 }
132
133 static int tolua_collect_CheckBox (lua_State* tolua_S)
134 {
135 CheckBox* self = (CheckBox*) tolua_tousertype(tolua_S,1,0);
136 Mtolua_delete(self);
137 return 0;
138 }
139
140 static int tolua_collect_ImageWidget (lua_State* tolua_S)
141 {
142 ImageWidget* self = (ImageWidget*) tolua_tousertype(tolua_S,1,0);
143 Mtolua_delete(self);
144 return 0;
145 }
146
147 static int tolua_collect_CPlayer (lua_State* tolua_S)
148 {
149 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
150 Mtolua_delete(self);
151 return 0;
152 }
153
154 static int tolua_collect_CColor (lua_State* tolua_S)
155 {
156 CColor* self = (CColor*) tolua_tousertype(tolua_S,1,0);
157 Mtolua_delete(self);
158 return 0;
159 }
160
161 static int tolua_collect_ImageSlider (lua_State* tolua_S)
162 {
163 ImageSlider* self = (ImageSlider*) tolua_tousertype(tolua_S,1,0);
164 Mtolua_delete(self);
165 return 0;
166 }
167
168 static int tolua_collect_ListBoxWidget (lua_State* tolua_S)
169 {
170 ListBoxWidget* self = (ListBoxWidget*) tolua_tousertype(tolua_S,1,0);
171 Mtolua_delete(self);
172 return 0;
173 }
174
175 static int tolua_collect_Color (lua_State* tolua_S)
176 {
177 Color* self = (Color*) tolua_tousertype(tolua_S,1,0);
178 Mtolua_delete(self);
179 return 0;
180 }
181
182 static int tolua_collect_Window (lua_State* tolua_S)
183 {
184 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
185 Mtolua_delete(self);
186 return 0;
187 }
188
189 static int tolua_collect_DropDownWidget (lua_State* tolua_S)
190 {
191 DropDownWidget* self = (DropDownWidget*) tolua_tousertype(tolua_S,1,0);
192 Mtolua_delete(self);
193 return 0;
194 }
195
196 static int tolua_collect_CFiller (lua_State* tolua_S)
197 {
198 CFiller* self = (CFiller*) tolua_tousertype(tolua_S,1,0);
199 Mtolua_delete(self);
200 return 0;
201 }
202
203 static int tolua_collect_vector_string_ (lua_State* tolua_S)
204 {
205 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
206 Mtolua_delete(self);
207 return 0;
208 }
209
210 static int tolua_collect_ScrollArea (lua_State* tolua_S)
211 {
212 ScrollArea* self = (ScrollArea*) tolua_tousertype(tolua_S,1,0);
213 Mtolua_delete(self);
214 return 0;
215 }
216
217 static int tolua_collect_Windows (lua_State* tolua_S)
218 {
219 Windows* self = (Windows*) tolua_tousertype(tolua_S,1,0);
220 Mtolua_delete(self);
221 return 0;
222 }
223
224 static int tolua_collect_Container (lua_State* tolua_S)
225 {
226 Container* self = (Container*) tolua_tousertype(tolua_S,1,0);
227 Mtolua_delete(self);
228 return 0;
229 }
230
231 static int tolua_collect_ButtonWidget (lua_State* tolua_S)
232 {
233 ButtonWidget* self = (ButtonWidget*) tolua_tousertype(tolua_S,1,0);
234 Mtolua_delete(self);
235 return 0;
236 }
237
238 static int tolua_collect_CParticleManager (lua_State* tolua_S)
239 {
240 CParticleManager* self = (CParticleManager*) tolua_tousertype(tolua_S,1,0);
241 Mtolua_delete(self);
242 return 0;
243 }
244
245 static int tolua_collect_ImageCheckBox (lua_State* tolua_S)
246 {
247 ImageCheckBox* self = (ImageCheckBox*) tolua_tousertype(tolua_S,1,0);
248 Mtolua_delete(self);
249 return 0;
250 }
251
252 static int tolua_collect_ScrollingWidget (lua_State* tolua_S)
253 {
254 ScrollingWidget* self = (ScrollingWidget*) tolua_tousertype(tolua_S,1,0);
255 Mtolua_delete(self);
256 return 0;
257 }
258
259 static int tolua_collect_CNetworkHost (lua_State* tolua_S)
260 {
261 CNetworkHost* self = (CNetworkHost*) tolua_tousertype(tolua_S,1,0);
262 Mtolua_delete(self);
263 return 0;
264 }
265
266 static int tolua_collect_StatBoxWidget (lua_State* tolua_S)
267 {
268 StatBoxWidget* self = (StatBoxWidget*) tolua_tousertype(tolua_S,1,0);
269 Mtolua_delete(self);
270 return 0;
271 }
272
273 static int tolua_collect_SettingsPresets (lua_State* tolua_S)
274 {
275 SettingsPresets* self = (SettingsPresets*) tolua_tousertype(tolua_S,1,0);
276 Mtolua_delete(self);
277 return 0;
278 }
279
280 static int tolua_collect_CPosition (lua_State* tolua_S)
281 {
282 CPosition* self = (CPosition*) tolua_tousertype(tolua_S,1,0);
283 Mtolua_delete(self);
284 return 0;
285 }
286
287 static int tolua_collect_GraphicAnimation (lua_State* tolua_S)
288 {
289 GraphicAnimation* self = (GraphicAnimation*) tolua_tousertype(tolua_S,1,0);
290 Mtolua_delete(self);
291 return 0;
292 }
293
294 static int tolua_collect_Label (lua_State* tolua_S)
295 {
296 Label* self = (Label*) tolua_tousertype(tolua_S,1,0);
297 Mtolua_delete(self);
298 return 0;
299 }
300
301 static int tolua_collect_RadioButton (lua_State* tolua_S)
302 {
303 RadioButton* self = (RadioButton*) tolua_tousertype(tolua_S,1,0);
304 Mtolua_delete(self);
305 return 0;
306 }
307
308 static int tolua_collect_LuaActionListener (lua_State* tolua_S)
309 {
310 LuaActionListener* self = (LuaActionListener*) tolua_tousertype(tolua_S,1,0);
311 Mtolua_delete(self);
312 return 0;
313 }
314
315 static int tolua_collect_StaticParticle (lua_State* tolua_S)
316 {
317 StaticParticle* self = (StaticParticle*) tolua_tousertype(tolua_S,1,0);
318 Mtolua_delete(self);
319 return 0;
320 }
321
322 static int tolua_collect_ImageButton (lua_State* tolua_S)
323 {
324 ImageButton* self = (ImageButton*) tolua_tousertype(tolua_S,1,0);
325 Mtolua_delete(self);
326 return 0;
327 }
328
329 static int tolua_collect_Slider (lua_State* tolua_S)
330 {
331 Slider* self = (Slider*) tolua_tousertype(tolua_S,1,0);
332 Mtolua_delete(self);
333 return 0;
334 }
335 #endif
336
337
338 /* function to register type */
339 static void tolua_reg_types (lua_State* tolua_S)
340 {
341 tolua_usertype(tolua_S,"CPlayerColorGraphic");
342 tolua_usertype(tolua_S,"MenuScreen");
343 tolua_usertype(tolua_S,"BasicContainer");
344 tolua_usertype(tolua_S,"vector<CUIButton>");
345 tolua_usertype(tolua_S,"CFontColor");
346 tolua_usertype(tolua_S,"CMap");
347 tolua_usertype(tolua_S,"CChunkParticle");
348 tolua_usertype(tolua_S,"CIcon");
349 tolua_usertype(tolua_S,"CUIButton");
350 tolua_usertype(tolua_S,"CheckBox");
351 tolua_usertype(tolua_S,"ImageButton");
352 tolua_usertype(tolua_S,"CPlayer");
353 tolua_usertype(tolua_S,"CUnit");
354 tolua_usertype(tolua_S,"CParticle");
355 tolua_usertype(tolua_S,"Graphics");
356 tolua_usertype(tolua_S,"CColor");
357 tolua_usertype(tolua_S,"CButtonPanel");
358 tolua_usertype(tolua_S,"CPatch");
359 tolua_usertype(tolua_S,"ImageSlider");
360 tolua_usertype(tolua_S,"ListBoxWidget");
361 tolua_usertype(tolua_S,"Color");
362 tolua_usertype(tolua_S,"ButtonStyle");
363 tolua_usertype(tolua_S,"DropDownWidget");
364 tolua_usertype(tolua_S,"CPieMenu");
365 tolua_usertype(tolua_S,"ScrollArea");
366 tolua_usertype(tolua_S,"Button");
367 tolua_usertype(tolua_S,"CInfoPanel");
368 tolua_usertype(tolua_S,"Animation");
369 tolua_usertype(tolua_S,"ScrollingWidget");
370 tolua_usertype(tolua_S,"CGraphic");
371 tolua_usertype(tolua_S,"StatBoxWidget");
372 tolua_usertype(tolua_S,"CUITimer");
373 tolua_usertype(tolua_S,"Widget");
374 tolua_usertype(tolua_S,"Label");
375 tolua_usertype(tolua_S,"Settings");
376 tolua_usertype(tolua_S,"CResourceInfo");
377 tolua_usertype(tolua_S,"vector<CFiller>");
378 tolua_usertype(tolua_S,"CUnitType");
379 tolua_usertype(tolua_S,"CMapInfo");
380 tolua_usertype(tolua_S,"TextField");
381 tolua_usertype(tolua_S,"CServerSetup");
382 tolua_usertype(tolua_S,"CMapArea");
383 tolua_usertype(tolua_S,"ImageWidget");
384 tolua_usertype(tolua_S,"SettingsPresets");
385 tolua_usertype(tolua_S,"gcn::Graphics");
386 tolua_usertype(tolua_S,"CStatusLine");
387 tolua_usertype(tolua_S,"CMinimap");
388 tolua_usertype(tolua_S,"CPatchManager");
389 tolua_usertype(tolua_S,"Window");
390 tolua_usertype(tolua_S,"CParticleManager");
391 tolua_usertype(tolua_S,"CPreference");
392 tolua_usertype(tolua_S,"CFiller");
393 tolua_usertype(tolua_S,"CUserInterface");
394 tolua_usertype(tolua_S,"vector<string>");
395 tolua_usertype(tolua_S,"Windows");
396 tolua_usertype(tolua_S,"MultiLineLabel");
397 tolua_usertype(tolua_S,"CSmokeParticle");
398 tolua_usertype(tolua_S,"CPatchType");
399 tolua_usertype(tolua_S,"Container");
400 tolua_usertype(tolua_S,"ButtonWidget");
401 tolua_usertype(tolua_S,"CFont");
402 tolua_usertype(tolua_S,"CVideo");
403 tolua_usertype(tolua_S,"ImageCheckBox");
404 tolua_usertype(tolua_S,"LuaActionListener");
405 tolua_usertype(tolua_S,"ImageRadioButton");
406 tolua_usertype(tolua_S,"CEditor");
407 tolua_usertype(tolua_S,"ListBox");
408 tolua_usertype(tolua_S,"CPosition");
409 tolua_usertype(tolua_S,"GraphicAnimation");
410 tolua_usertype(tolua_S,"CNetworkHost");
411 tolua_usertype(tolua_S,"RadioButton");
412 tolua_usertype(tolua_S,"CViewport");
413 tolua_usertype(tolua_S,"StaticParticle");
414 tolua_usertype(tolua_S,"DropDown");
415 tolua_usertype(tolua_S,"Slider");
416 }
417
418 /* get function: X of class CMinimap */
419 #ifndef TOLUA_DISABLE_tolua_get_CMinimap_X
420 static int tolua_get_CMinimap_X(lua_State* tolua_S)
421 {
422 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
423 #ifndef TOLUA_RELEASE
424 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
425 #endif
426 tolua_pushnumber(tolua_S,(lua_Number)self->X);
427 return 1;
428 }
429 #endif //#ifndef TOLUA_DISABLE
430
431 /* set function: X of class CMinimap */
432 #ifndef TOLUA_DISABLE_tolua_set_CMinimap_X
433 static int tolua_set_CMinimap_X(lua_State* tolua_S)
434 {
435 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
436 #ifndef TOLUA_RELEASE
437 tolua_Error tolua_err;
438 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
439 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
440 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
441 #endif
442 self->X = ((int) tolua_tonumber(tolua_S,2,0))
443 ;
444 return 0;
445 }
446 #endif //#ifndef TOLUA_DISABLE
447
448 /* get function: Y of class CMinimap */
449 #ifndef TOLUA_DISABLE_tolua_get_CMinimap_Y
450 static int tolua_get_CMinimap_Y(lua_State* tolua_S)
451 {
452 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
453 #ifndef TOLUA_RELEASE
454 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
455 #endif
456 tolua_pushnumber(tolua_S,(lua_Number)self->Y);
457 return 1;
458 }
459 #endif //#ifndef TOLUA_DISABLE
460
461 /* set function: Y of class CMinimap */
462 #ifndef TOLUA_DISABLE_tolua_set_CMinimap_Y
463 static int tolua_set_CMinimap_Y(lua_State* tolua_S)
464 {
465 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
466 #ifndef TOLUA_RELEASE
467 tolua_Error tolua_err;
468 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
469 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
470 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
471 #endif
472 self->Y = ((int) tolua_tonumber(tolua_S,2,0))
473 ;
474 return 0;
475 }
476 #endif //#ifndef TOLUA_DISABLE
477
478 /* get function: W of class CMinimap */
479 #ifndef TOLUA_DISABLE_tolua_get_CMinimap_W
480 static int tolua_get_CMinimap_W(lua_State* tolua_S)
481 {
482 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
483 #ifndef TOLUA_RELEASE
484 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'W'",NULL);
485 #endif
486 tolua_pushnumber(tolua_S,(lua_Number)self->W);
487 return 1;
488 }
489 #endif //#ifndef TOLUA_DISABLE
490
491 /* set function: W of class CMinimap */
492 #ifndef TOLUA_DISABLE_tolua_set_CMinimap_W
493 static int tolua_set_CMinimap_W(lua_State* tolua_S)
494 {
495 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
496 #ifndef TOLUA_RELEASE
497 tolua_Error tolua_err;
498 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'W'",NULL);
499 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
500 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
501 #endif
502 self->W = ((int) tolua_tonumber(tolua_S,2,0))
503 ;
504 return 0;
505 }
506 #endif //#ifndef TOLUA_DISABLE
507
508 /* get function: H of class CMinimap */
509 #ifndef TOLUA_DISABLE_tolua_get_CMinimap_H
510 static int tolua_get_CMinimap_H(lua_State* tolua_S)
511 {
512 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
513 #ifndef TOLUA_RELEASE
514 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'H'",NULL);
515 #endif
516 tolua_pushnumber(tolua_S,(lua_Number)self->H);
517 return 1;
518 }
519 #endif //#ifndef TOLUA_DISABLE
520
521 /* set function: H of class CMinimap */
522 #ifndef TOLUA_DISABLE_tolua_set_CMinimap_H
523 static int tolua_set_CMinimap_H(lua_State* tolua_S)
524 {
525 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
526 #ifndef TOLUA_RELEASE
527 tolua_Error tolua_err;
528 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'H'",NULL);
529 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
530 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
531 #endif
532 self->H = ((int) tolua_tonumber(tolua_S,2,0))
533 ;
534 return 0;
535 }
536 #endif //#ifndef TOLUA_DISABLE
537
538 /* get function: WithTerrain of class CMinimap */
539 #ifndef TOLUA_DISABLE_tolua_get_CMinimap_WithTerrain
540 static int tolua_get_CMinimap_WithTerrain(lua_State* tolua_S)
541 {
542 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
543 #ifndef TOLUA_RELEASE
544 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'WithTerrain'",NULL);
545 #endif
546 tolua_pushboolean(tolua_S,(bool)self->WithTerrain);
547 return 1;
548 }
549 #endif //#ifndef TOLUA_DISABLE
550
551 /* set function: WithTerrain of class CMinimap */
552 #ifndef TOLUA_DISABLE_tolua_set_CMinimap_WithTerrain
553 static int tolua_set_CMinimap_WithTerrain(lua_State* tolua_S)
554 {
555 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
556 #ifndef TOLUA_RELEASE
557 tolua_Error tolua_err;
558 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'WithTerrain'",NULL);
559 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
560 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
561 #endif
562 self->WithTerrain = ((bool) tolua_toboolean(tolua_S,2,0))
563 ;
564 return 0;
565 }
566 #endif //#ifndef TOLUA_DISABLE
567
568 /* get function: ShowSelected of class CMinimap */
569 #ifndef TOLUA_DISABLE_tolua_get_CMinimap_ShowSelected
570 static int tolua_get_CMinimap_ShowSelected(lua_State* tolua_S)
571 {
572 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
573 #ifndef TOLUA_RELEASE
574 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowSelected'",NULL);
575 #endif
576 tolua_pushboolean(tolua_S,(bool)self->ShowSelected);
577 return 1;
578 }
579 #endif //#ifndef TOLUA_DISABLE
580
581 /* set function: ShowSelected of class CMinimap */
582 #ifndef TOLUA_DISABLE_tolua_set_CMinimap_ShowSelected
583 static int tolua_set_CMinimap_ShowSelected(lua_State* tolua_S)
584 {
585 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
586 #ifndef TOLUA_RELEASE
587 tolua_Error tolua_err;
588 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowSelected'",NULL);
589 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
590 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
591 #endif
592 self->ShowSelected = ((bool) tolua_toboolean(tolua_S,2,0))
593 ;
594 return 0;
595 }
596 #endif //#ifndef TOLUA_DISABLE
597
598 /* get function: Transparent of class CMinimap */
599 #ifndef TOLUA_DISABLE_tolua_get_CMinimap_Transparent
600 static int tolua_get_CMinimap_Transparent(lua_State* tolua_S)
601 {
602 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
603 #ifndef TOLUA_RELEASE
604 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Transparent'",NULL);
605 #endif
606 tolua_pushboolean(tolua_S,(bool)self->Transparent);
607 return 1;
608 }
609 #endif //#ifndef TOLUA_DISABLE
610
611 /* set function: Transparent of class CMinimap */
612 #ifndef TOLUA_DISABLE_tolua_set_CMinimap_Transparent
613 static int tolua_set_CMinimap_Transparent(lua_State* tolua_S)
614 {
615 CMinimap* self = (CMinimap*) tolua_tousertype(tolua_S,1,0);
616 #ifndef TOLUA_RELEASE
617 tolua_Error tolua_err;
618 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Transparent'",NULL);
619 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
620 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
621 #endif
622 self->Transparent = ((bool) tolua_toboolean(tolua_S,2,0))
623 ;
624 return 0;
625 }
626 #endif //#ifndef TOLUA_DISABLE
627
628 /* method: new of class LuaActionListener */
629 #ifndef TOLUA_DISABLE_tolua_stratagus_LuaActionListener_new00
630 static int tolua_stratagus_LuaActionListener_new00(lua_State* tolua_S)
631 {
632 #ifndef TOLUA_RELEASE
633 tolua_Error tolua_err;
634 if (
635 !tolua_isusertable(tolua_S,1,"LuaActionListener",0,&tolua_err) ||
636 !tolua_isnoobj(tolua_S,3,&tolua_err)
637 )
638 goto tolua_lerror;
639 else
640 #endif
641 {
642 lua_State* lua = tolua_S;
643 lua_Object luaref = ((lua_Object) tolua_tovalue(tolua_S,2,0));
644 {
645 LuaActionListener* tolua_ret = (LuaActionListener*) Mtolua_new((LuaActionListener)(lua,luaref));
646 tolua_pushusertype(tolua_S,(void*)tolua_ret,"LuaActionListener");
647 }
648 }
649 return 1;
650 #ifndef TOLUA_RELEASE
651 tolua_lerror:
652 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
653 return 0;
654 #endif
655 }
656 #endif //#ifndef TOLUA_DISABLE
657
658 /* method: new_local of class LuaActionListener */
659 #ifndef TOLUA_DISABLE_tolua_stratagus_LuaActionListener_new00_local
660 static int tolua_stratagus_LuaActionListener_new00_local(lua_State* tolua_S)
661 {
662 #ifndef TOLUA_RELEASE
663 tolua_Error tolua_err;
664 if (
665 !tolua_isusertable(tolua_S,1,"LuaActionListener",0,&tolua_err) ||
666 !tolua_isnoobj(tolua_S,3,&tolua_err)
667 )
668 goto tolua_lerror;
669 else
670 #endif
671 {
672 lua_State* lua = tolua_S;
673 lua_Object luaref = ((lua_Object) tolua_tovalue(tolua_S,2,0));
674 {
675 LuaActionListener* tolua_ret = (LuaActionListener*) Mtolua_new((LuaActionListener)(lua,luaref));
676 tolua_pushusertype(tolua_S,(void*)tolua_ret,"LuaActionListener");
677 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
678 }
679 }
680 return 1;
681 #ifndef TOLUA_RELEASE
682 tolua_lerror:
683 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
684 return 0;
685 #endif
686 }
687 #endif //#ifndef TOLUA_DISABLE
688
689 /* method: new of class CUIButton */
690 #ifndef TOLUA_DISABLE_tolua_stratagus_CUIButton_new00
691 static int tolua_stratagus_CUIButton_new00(lua_State* tolua_S)
692 {
693 #ifndef TOLUA_RELEASE
694 tolua_Error tolua_err;
695 if (
696 !tolua_isusertable(tolua_S,1,"CUIButton",0,&tolua_err) ||
697 !tolua_isnoobj(tolua_S,2,&tolua_err)
698 )
699 goto tolua_lerror;
700 else
701 #endif
702 {
703 {
704 CUIButton* tolua_ret = (CUIButton*) Mtolua_new((CUIButton)());
705 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CUIButton");
706 }
707 }
708 return 1;
709 #ifndef TOLUA_RELEASE
710 tolua_lerror:
711 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
712 return 0;
713 #endif
714 }
715 #endif //#ifndef TOLUA_DISABLE
716
717 /* method: new_local of class CUIButton */
718 #ifndef TOLUA_DISABLE_tolua_stratagus_CUIButton_new00_local
719 static int tolua_stratagus_CUIButton_new00_local(lua_State* tolua_S)
720 {
721 #ifndef TOLUA_RELEASE
722 tolua_Error tolua_err;
723 if (
724 !tolua_isusertable(tolua_S,1,"CUIButton",0,&tolua_err) ||
725 !tolua_isnoobj(tolua_S,2,&tolua_err)
726 )
727 goto tolua_lerror;
728 else
729 #endif
730 {
731 {
732 CUIButton* tolua_ret = (CUIButton*) Mtolua_new((CUIButton)());
733 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CUIButton");
734 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
735 }
736 }
737 return 1;
738 #ifndef TOLUA_RELEASE
739 tolua_lerror:
740 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
741 return 0;
742 #endif
743 }
744 #endif //#ifndef TOLUA_DISABLE
745
746 /* method: delete of class CUIButton */
747 #ifndef TOLUA_DISABLE_tolua_stratagus_CUIButton_delete00
748 static int tolua_stratagus_CUIButton_delete00(lua_State* tolua_S)
749 {
750 #ifndef TOLUA_RELEASE
751 tolua_Error tolua_err;
752 if (
753 !tolua_isusertype(tolua_S,1,"CUIButton",0,&tolua_err) ||
754 !tolua_isnoobj(tolua_S,2,&tolua_err)
755 )
756 goto tolua_lerror;
757 else
758 #endif
759 {
760 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
761 #ifndef TOLUA_RELEASE
762 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
763 #endif
764 Mtolua_delete(self);
765 }
766 return 0;
767 #ifndef TOLUA_RELEASE
768 tolua_lerror:
769 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
770 return 0;
771 #endif
772 }
773 #endif //#ifndef TOLUA_DISABLE
774
775 /* get function: X of class CUIButton */
776 #ifndef TOLUA_DISABLE_tolua_get_CUIButton_X
777 static int tolua_get_CUIButton_X(lua_State* tolua_S)
778 {
779 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
780 #ifndef TOLUA_RELEASE
781 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
782 #endif
783 tolua_pushnumber(tolua_S,(lua_Number)self->X);
784 return 1;
785 }
786 #endif //#ifndef TOLUA_DISABLE
787
788 /* set function: X of class CUIButton */
789 #ifndef TOLUA_DISABLE_tolua_set_CUIButton_X
790 static int tolua_set_CUIButton_X(lua_State* tolua_S)
791 {
792 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
793 #ifndef TOLUA_RELEASE
794 tolua_Error tolua_err;
795 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
796 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
797 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
798 #endif
799 self->X = ((int) tolua_tonumber(tolua_S,2,0))
800 ;
801 return 0;
802 }
803 #endif //#ifndef TOLUA_DISABLE
804
805 /* get function: Y of class CUIButton */
806 #ifndef TOLUA_DISABLE_tolua_get_CUIButton_Y
807 static int tolua_get_CUIButton_Y(lua_State* tolua_S)
808 {
809 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
810 #ifndef TOLUA_RELEASE
811 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
812 #endif
813 tolua_pushnumber(tolua_S,(lua_Number)self->Y);
814 return 1;
815 }
816 #endif //#ifndef TOLUA_DISABLE
817
818 /* set function: Y of class CUIButton */
819 #ifndef TOLUA_DISABLE_tolua_set_CUIButton_Y
820 static int tolua_set_CUIButton_Y(lua_State* tolua_S)
821 {
822 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
823 #ifndef TOLUA_RELEASE
824 tolua_Error tolua_err;
825 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
826 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
827 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
828 #endif
829 self->Y = ((int) tolua_tonumber(tolua_S,2,0))
830 ;
831 return 0;
832 }
833 #endif //#ifndef TOLUA_DISABLE
834
835 /* get function: Text of class CUIButton */
836 #ifndef TOLUA_DISABLE_tolua_get_CUIButton_Text
837 static int tolua_get_CUIButton_Text(lua_State* tolua_S)
838 {
839 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
840 #ifndef TOLUA_RELEASE
841 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Text'",NULL);
842 #endif
843 tolua_pushcppstring(tolua_S,(const char*)self->Text);
844 return 1;
845 }
846 #endif //#ifndef TOLUA_DISABLE
847
848 /* set function: Text of class CUIButton */
849 #ifndef TOLUA_DISABLE_tolua_set_CUIButton_Text
850 static int tolua_set_CUIButton_Text(lua_State* tolua_S)
851 {
852 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
853 #ifndef TOLUA_RELEASE
854 tolua_Error tolua_err;
855 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Text'",NULL);
856 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
857 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
858 #endif
859 self->Text = ((string) tolua_tocppstring(tolua_S,2,0))
860 ;
861 return 0;
862 }
863 #endif //#ifndef TOLUA_DISABLE
864
865 /* get function: Style of class CUIButton */
866 #ifndef TOLUA_DISABLE_tolua_get_CUIButton_Style_ptr
867 static int tolua_get_CUIButton_Style_ptr(lua_State* tolua_S)
868 {
869 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
870 #ifndef TOLUA_RELEASE
871 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Style'",NULL);
872 #endif
873 tolua_pushusertype(tolua_S,(void*)self->Style,"ButtonStyle");
874 return 1;
875 }
876 #endif //#ifndef TOLUA_DISABLE
877
878 /* set function: Style of class CUIButton */
879 #ifndef TOLUA_DISABLE_tolua_set_CUIButton_Style_ptr
880 static int tolua_set_CUIButton_Style_ptr(lua_State* tolua_S)
881 {
882 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
883 #ifndef TOLUA_RELEASE
884 tolua_Error tolua_err;
885 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Style'",NULL);
886 if (!tolua_isusertype(tolua_S,2,"ButtonStyle",0,&tolua_err))
887 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
888 #endif
889 self->Style = ((ButtonStyle*) tolua_tousertype(tolua_S,2,0))
890 ;
891 return 0;
892 }
893 #endif //#ifndef TOLUA_DISABLE
894
895 /* get function: Callback of class CUIButton */
896 #ifndef TOLUA_DISABLE_tolua_get_CUIButton_Callback_ptr
897 static int tolua_get_CUIButton_Callback_ptr(lua_State* tolua_S)
898 {
899 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
900 #ifndef TOLUA_RELEASE
901 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Callback'",NULL);
902 #endif
903 tolua_pushusertype(tolua_S,(void*)self->Callback,"LuaActionListener");
904 return 1;
905 }
906 #endif //#ifndef TOLUA_DISABLE
907
908 /* set function: Callback of class CUIButton */
909 #ifndef TOLUA_DISABLE_tolua_set_CUIButton_Callback_ptr
910 static int tolua_set_CUIButton_Callback_ptr(lua_State* tolua_S)
911 {
912 CUIButton* self = (CUIButton*) tolua_tousertype(tolua_S,1,0);
913 #ifndef TOLUA_RELEASE
914 tolua_Error tolua_err;
915 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Callback'",NULL);
916 if (!tolua_isusertype(tolua_S,2,"LuaActionListener",0,&tolua_err))
917 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
918 #endif
919 self->Callback = ((LuaActionListener*) tolua_tousertype(tolua_S,2,0))
920 ;
921 return 0;
922 }
923 #endif //#ifndef TOLUA_DISABLE
924
925 /* get function: X of class CMapArea */
926 #ifndef TOLUA_DISABLE_tolua_get_CMapArea_X
927 static int tolua_get_CMapArea_X(lua_State* tolua_S)
928 {
929 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
930 #ifndef TOLUA_RELEASE
931 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
932 #endif
933 tolua_pushnumber(tolua_S,(lua_Number)self->X);
934 return 1;
935 }
936 #endif //#ifndef TOLUA_DISABLE
937
938 /* set function: X of class CMapArea */
939 #ifndef TOLUA_DISABLE_tolua_set_CMapArea_X
940 static int tolua_set_CMapArea_X(lua_State* tolua_S)
941 {
942 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
943 #ifndef TOLUA_RELEASE
944 tolua_Error tolua_err;
945 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
946 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
947 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
948 #endif
949 self->X = ((int) tolua_tonumber(tolua_S,2,0))
950 ;
951 return 0;
952 }
953 #endif //#ifndef TOLUA_DISABLE
954
955 /* get function: Y of class CMapArea */
956 #ifndef TOLUA_DISABLE_tolua_get_CMapArea_Y
957 static int tolua_get_CMapArea_Y(lua_State* tolua_S)
958 {
959 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
960 #ifndef TOLUA_RELEASE
961 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
962 #endif
963 tolua_pushnumber(tolua_S,(lua_Number)self->Y);
964 return 1;
965 }
966 #endif //#ifndef TOLUA_DISABLE
967
968 /* set function: Y of class CMapArea */
969 #ifndef TOLUA_DISABLE_tolua_set_CMapArea_Y
970 static int tolua_set_CMapArea_Y(lua_State* tolua_S)
971 {
972 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
973 #ifndef TOLUA_RELEASE
974 tolua_Error tolua_err;
975 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
976 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
977 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
978 #endif
979 self->Y = ((int) tolua_tonumber(tolua_S,2,0))
980 ;
981 return 0;
982 }
983 #endif //#ifndef TOLUA_DISABLE
984
985 /* get function: EndX of class CMapArea */
986 #ifndef TOLUA_DISABLE_tolua_get_CMapArea_EndX
987 static int tolua_get_CMapArea_EndX(lua_State* tolua_S)
988 {
989 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
990 #ifndef TOLUA_RELEASE
991 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EndX'",NULL);
992 #endif
993 tolua_pushnumber(tolua_S,(lua_Number)self->EndX);
994 return 1;
995 }
996 #endif //#ifndef TOLUA_DISABLE
997
998 /* set function: EndX of class CMapArea */
999 #ifndef TOLUA_DISABLE_tolua_set_CMapArea_EndX
1000 static int tolua_set_CMapArea_EndX(lua_State* tolua_S)
1001 {
1002 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1003 #ifndef TOLUA_RELEASE
1004 tolua_Error tolua_err;
1005 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EndX'",NULL);
1006 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1007 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1008 #endif
1009 self->EndX = ((int) tolua_tonumber(tolua_S,2,0))
1010 ;
1011 return 0;
1012 }
1013 #endif //#ifndef TOLUA_DISABLE
1014
1015 /* get function: EndY of class CMapArea */
1016 #ifndef TOLUA_DISABLE_tolua_get_CMapArea_EndY
1017 static int tolua_get_CMapArea_EndY(lua_State* tolua_S)
1018 {
1019 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1020 #ifndef TOLUA_RELEASE
1021 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EndY'",NULL);
1022 #endif
1023 tolua_pushnumber(tolua_S,(lua_Number)self->EndY);
1024 return 1;
1025 }
1026 #endif //#ifndef TOLUA_DISABLE
1027
1028 /* set function: EndY of class CMapArea */
1029 #ifndef TOLUA_DISABLE_tolua_set_CMapArea_EndY
1030 static int tolua_set_CMapArea_EndY(lua_State* tolua_S)
1031 {
1032 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1033 #ifndef TOLUA_RELEASE
1034 tolua_Error tolua_err;
1035 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EndY'",NULL);
1036 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1037 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1038 #endif
1039 self->EndY = ((int) tolua_tonumber(tolua_S,2,0))
1040 ;
1041 return 0;
1042 }
1043 #endif //#ifndef TOLUA_DISABLE
1044
1045 /* get function: ScrollPaddingLeft of class CMapArea */
1046 #ifndef TOLUA_DISABLE_tolua_get_CMapArea_ScrollPaddingLeft
1047 static int tolua_get_CMapArea_ScrollPaddingLeft(lua_State* tolua_S)
1048 {
1049 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1050 #ifndef TOLUA_RELEASE
1051 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ScrollPaddingLeft'",NULL);
1052 #endif
1053 tolua_pushnumber(tolua_S,(lua_Number)self->ScrollPaddingLeft);
1054 return 1;
1055 }
1056 #endif //#ifndef TOLUA_DISABLE
1057
1058 /* set function: ScrollPaddingLeft of class CMapArea */
1059 #ifndef TOLUA_DISABLE_tolua_set_CMapArea_ScrollPaddingLeft
1060 static int tolua_set_CMapArea_ScrollPaddingLeft(lua_State* tolua_S)
1061 {
1062 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1063 #ifndef TOLUA_RELEASE
1064 tolua_Error tolua_err;
1065 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ScrollPaddingLeft'",NULL);
1066 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1067 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1068 #endif
1069 self->ScrollPaddingLeft = ((int) tolua_tonumber(tolua_S,2,0))
1070 ;
1071 return 0;
1072 }
1073 #endif //#ifndef TOLUA_DISABLE
1074
1075 /* get function: ScrollPaddingRight of class CMapArea */
1076 #ifndef TOLUA_DISABLE_tolua_get_CMapArea_ScrollPaddingRight
1077 static int tolua_get_CMapArea_ScrollPaddingRight(lua_State* tolua_S)
1078 {
1079 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1080 #ifndef TOLUA_RELEASE
1081 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ScrollPaddingRight'",NULL);
1082 #endif
1083 tolua_pushnumber(tolua_S,(lua_Number)self->ScrollPaddingRight);
1084 return 1;
1085 }
1086 #endif //#ifndef TOLUA_DISABLE
1087
1088 /* set function: ScrollPaddingRight of class CMapArea */
1089 #ifndef TOLUA_DISABLE_tolua_set_CMapArea_ScrollPaddingRight
1090 static int tolua_set_CMapArea_ScrollPaddingRight(lua_State* tolua_S)
1091 {
1092 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1093 #ifndef TOLUA_RELEASE
1094 tolua_Error tolua_err;
1095 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ScrollPaddingRight'",NULL);
1096 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1097 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1098 #endif
1099 self->ScrollPaddingRight = ((int) tolua_tonumber(tolua_S,2,0))
1100 ;
1101 return 0;
1102 }
1103 #endif //#ifndef TOLUA_DISABLE
1104
1105 /* get function: ScrollPaddingTop of class CMapArea */
1106 #ifndef TOLUA_DISABLE_tolua_get_CMapArea_ScrollPaddingTop
1107 static int tolua_get_CMapArea_ScrollPaddingTop(lua_State* tolua_S)
1108 {
1109 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1110 #ifndef TOLUA_RELEASE
1111 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ScrollPaddingTop'",NULL);
1112 #endif
1113 tolua_pushnumber(tolua_S,(lua_Number)self->ScrollPaddingTop);
1114 return 1;
1115 }
1116 #endif //#ifndef TOLUA_DISABLE
1117
1118 /* set function: ScrollPaddingTop of class CMapArea */
1119 #ifndef TOLUA_DISABLE_tolua_set_CMapArea_ScrollPaddingTop
1120 static int tolua_set_CMapArea_ScrollPaddingTop(lua_State* tolua_S)
1121 {
1122 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1123 #ifndef TOLUA_RELEASE
1124 tolua_Error tolua_err;
1125 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ScrollPaddingTop'",NULL);
1126 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1127 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1128 #endif
1129 self->ScrollPaddingTop = ((int) tolua_tonumber(tolua_S,2,0))
1130 ;
1131 return 0;
1132 }
1133 #endif //#ifndef TOLUA_DISABLE
1134
1135 /* get function: ScrollPaddingBottom of class CMapArea */
1136 #ifndef TOLUA_DISABLE_tolua_get_CMapArea_ScrollPaddingBottom
1137 static int tolua_get_CMapArea_ScrollPaddingBottom(lua_State* tolua_S)
1138 {
1139 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1140 #ifndef TOLUA_RELEASE
1141 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ScrollPaddingBottom'",NULL);
1142 #endif
1143 tolua_pushnumber(tolua_S,(lua_Number)self->ScrollPaddingBottom);
1144 return 1;
1145 }
1146 #endif //#ifndef TOLUA_DISABLE
1147
1148 /* set function: ScrollPaddingBottom of class CMapArea */
1149 #ifndef TOLUA_DISABLE_tolua_set_CMapArea_ScrollPaddingBottom
1150 static int tolua_set_CMapArea_ScrollPaddingBottom(lua_State* tolua_S)
1151 {
1152 CMapArea* self = (CMapArea*) tolua_tousertype(tolua_S,1,0);
1153 #ifndef TOLUA_RELEASE
1154 tolua_Error tolua_err;
1155 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ScrollPaddingBottom'",NULL);
1156 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1157 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1158 #endif
1159 self->ScrollPaddingBottom = ((int) tolua_tonumber(tolua_S,2,0))
1160 ;
1161 return 0;
1162 }
1163 #endif //#ifndef TOLUA_DISABLE
1164
1165 /* method: Viewport2MapX of class CViewport */
1166 #ifndef TOLUA_DISABLE_tolua_stratagus_CViewport_Viewport2MapX00
1167 static int tolua_stratagus_CViewport_Viewport2MapX00(lua_State* tolua_S)
1168 {
1169 #ifndef TOLUA_RELEASE
1170 tolua_Error tolua_err;
1171 if (
1172 !tolua_isusertype(tolua_S,1,"CViewport",0,&tolua_err) ||
1173 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1174 !tolua_isnoobj(tolua_S,3,&tolua_err)
1175 )
1176 goto tolua_lerror;
1177 else
1178 #endif
1179 {
1180 CViewport* self = (CViewport*) tolua_tousertype(tolua_S,1,0);
1181 int x = ((int) tolua_tonumber(tolua_S,2,0));
1182 #ifndef TOLUA_RELEASE
1183 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Viewport2MapX'", NULL);
1184 #endif
1185 {
1186 int tolua_ret = (int) self->Viewport2MapX(x);
1187 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1188 }
1189 }
1190 return 1;
1191 #ifndef TOLUA_RELEASE
1192 tolua_lerror:
1193 tolua_error(tolua_S,"#ferror in function 'Viewport2MapX'.",&tolua_err);
1194 return 0;
1195 #endif
1196 }
1197 #endif //#ifndef TOLUA_DISABLE
1198
1199 /* method: Viewport2MapY of class CViewport */
1200 #ifndef TOLUA_DISABLE_tolua_stratagus_CViewport_Viewport2MapY00
1201 static int tolua_stratagus_CViewport_Viewport2MapY00(lua_State* tolua_S)
1202 {
1203 #ifndef TOLUA_RELEASE
1204 tolua_Error tolua_err;
1205 if (
1206 !tolua_isusertype(tolua_S,1,"CViewport",0,&tolua_err) ||
1207 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1208 !tolua_isnoobj(tolua_S,3,&tolua_err)
1209 )
1210 goto tolua_lerror;
1211 else
1212 #endif
1213 {
1214 CViewport* self = (CViewport*) tolua_tousertype(tolua_S,1,0);
1215 int y = ((int) tolua_tonumber(tolua_S,2,0));
1216 #ifndef TOLUA_RELEASE
1217 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Viewport2MapY'", NULL);
1218 #endif
1219 {
1220 int tolua_ret = (int) self->Viewport2MapY(y);
1221 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1222 }
1223 }
1224 return 1;
1225 #ifndef TOLUA_RELEASE
1226 tolua_lerror:
1227 tolua_error(tolua_S,"#ferror in function 'Viewport2MapY'.",&tolua_err);
1228 return 0;
1229 #endif
1230 }
1231 #endif //#ifndef TOLUA_DISABLE
1232
1233 /* method: new of class CFiller */
1234 #ifndef TOLUA_DISABLE_tolua_stratagus_CFiller_new00
1235 static int tolua_stratagus_CFiller_new00(lua_State* tolua_S)
1236 {
1237 #ifndef TOLUA_RELEASE
1238 tolua_Error tolua_err;
1239 if (
1240 !tolua_isusertable(tolua_S,1,"CFiller",0,&tolua_err) ||
1241 !tolua_isnoobj(tolua_S,2,&tolua_err)
1242 )
1243 goto tolua_lerror;
1244 else
1245 #endif
1246 {
1247 {
1248 CFiller* tolua_ret = (CFiller*) Mtolua_new((CFiller)());
1249 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CFiller");
1250 }
1251 }
1252 return 1;
1253 #ifndef TOLUA_RELEASE
1254 tolua_lerror:
1255 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1256 return 0;
1257 #endif
1258 }
1259 #endif //#ifndef TOLUA_DISABLE
1260
1261 /* method: new_local of class CFiller */
1262 #ifndef TOLUA_DISABLE_tolua_stratagus_CFiller_new00_local
1263 static int tolua_stratagus_CFiller_new00_local(lua_State* tolua_S)
1264 {
1265 #ifndef TOLUA_RELEASE
1266 tolua_Error tolua_err;
1267 if (
1268 !tolua_isusertable(tolua_S,1,"CFiller",0,&tolua_err) ||
1269 !tolua_isnoobj(tolua_S,2,&tolua_err)
1270 )
1271 goto tolua_lerror;
1272 else
1273 #endif
1274 {
1275 {
1276 CFiller* tolua_ret = (CFiller*) Mtolua_new((CFiller)());
1277 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CFiller");
1278 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1279 }
1280 }
1281 return 1;
1282 #ifndef TOLUA_RELEASE
1283 tolua_lerror:
1284 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1285 return 0;
1286 #endif
1287 }
1288 #endif //#ifndef TOLUA_DISABLE
1289
1290 /* get function: G of class CFiller */
1291 #ifndef TOLUA_DISABLE_tolua_get_CFiller_G_ptr
1292 static int tolua_get_CFiller_G_ptr(lua_State* tolua_S)
1293 {
1294 CFiller* self = (CFiller*) tolua_tousertype(tolua_S,1,0);
1295 #ifndef TOLUA_RELEASE
1296 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
1297 #endif
1298 tolua_pushusertype(tolua_S,(void*)self->G,"CGraphic");
1299 return 1;
1300 }
1301 #endif //#ifndef TOLUA_DISABLE
1302
1303 /* set function: G of class CFiller */
1304 #ifndef TOLUA_DISABLE_tolua_set_CFiller_G_ptr
1305 static int tolua_set_CFiller_G_ptr(lua_State* tolua_S)
1306 {
1307 CFiller* self = (CFiller*) tolua_tousertype(tolua_S,1,0);
1308 #ifndef TOLUA_RELEASE
1309 tolua_Error tolua_err;
1310 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
1311 if (!tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err))
1312 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1313 #endif
1314 self->G = ((CGraphic*) tolua_tousertype(tolua_S,2,0))
1315 ;
1316 return 0;
1317 }
1318 #endif //#ifndef TOLUA_DISABLE
1319
1320 /* get function: X of class CFiller */
1321 #ifndef TOLUA_DISABLE_tolua_get_CFiller_X
1322 static int tolua_get_CFiller_X(lua_State* tolua_S)
1323 {
1324 CFiller* self = (CFiller*) tolua_tousertype(tolua_S,1,0);
1325 #ifndef TOLUA_RELEASE
1326 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
1327 #endif
1328 tolua_pushnumber(tolua_S,(lua_Number)self->X);
1329 return 1;
1330 }
1331 #endif //#ifndef TOLUA_DISABLE
1332
1333 /* set function: X of class CFiller */
1334 #ifndef TOLUA_DISABLE_tolua_set_CFiller_X
1335 static int tolua_set_CFiller_X(lua_State* tolua_S)
1336 {
1337 CFiller* self = (CFiller*) tolua_tousertype(tolua_S,1,0);
1338 #ifndef TOLUA_RELEASE
1339 tolua_Error tolua_err;
1340 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
1341 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1342 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1343 #endif
1344 self->X = ((int) tolua_tonumber(tolua_S,2,0))
1345 ;
1346 return 0;
1347 }
1348 #endif //#ifndef TOLUA_DISABLE
1349
1350 /* get function: Y of class CFiller */
1351 #ifndef TOLUA_DISABLE_tolua_get_CFiller_Y
1352 static int tolua_get_CFiller_Y(lua_State* tolua_S)
1353 {
1354 CFiller* self = (CFiller*) tolua_tousertype(tolua_S,1,0);
1355 #ifndef TOLUA_RELEASE
1356 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
1357 #endif
1358 tolua_pushnumber(tolua_S,(lua_Number)self->Y);
1359 return 1;
1360 }
1361 #endif //#ifndef TOLUA_DISABLE
1362
1363 /* set function: Y of class CFiller */
1364 #ifndef TOLUA_DISABLE_tolua_set_CFiller_Y
1365 static int tolua_set_CFiller_Y(lua_State* tolua_S)
1366 {
1367 CFiller* self = (CFiller*) tolua_tousertype(tolua_S,1,0);
1368 #ifndef TOLUA_RELEASE
1369 tolua_Error tolua_err;
1370 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
1371 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1372 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1373 #endif
1374 self->Y = ((int) tolua_tonumber(tolua_S,2,0))
1375 ;
1376 return 0;
1377 }
1378 #endif //#ifndef TOLUA_DISABLE
1379
1380 /* method: new of class vector<CFiller> */
1381 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__new00
1382 static int tolua_stratagus_vector_CFiller__new00(lua_State* tolua_S)
1383 {
1384 #ifndef TOLUA_RELEASE
1385 tolua_Error tolua_err;
1386 if (
1387 !tolua_isusertable(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1388 !tolua_isnoobj(tolua_S,2,&tolua_err)
1389 )
1390 goto tolua_lerror;
1391 else
1392 #endif
1393 {
1394 {
1395 vector<CFiller>* tolua_ret = (vector<CFiller>*) Mtolua_new((vector<CFiller>)());
1396 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<CFiller>");
1397 }
1398 }
1399 return 1;
1400 #ifndef TOLUA_RELEASE
1401 tolua_lerror:
1402 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1403 return 0;
1404 #endif
1405 }
1406 #endif //#ifndef TOLUA_DISABLE
1407
1408 /* method: new_local of class vector<CFiller> */
1409 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__new00_local
1410 static int tolua_stratagus_vector_CFiller__new00_local(lua_State* tolua_S)
1411 {
1412 #ifndef TOLUA_RELEASE
1413 tolua_Error tolua_err;
1414 if (
1415 !tolua_isusertable(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1416 !tolua_isnoobj(tolua_S,2,&tolua_err)
1417 )
1418 goto tolua_lerror;
1419 else
1420 #endif
1421 {
1422 {
1423 vector<CFiller>* tolua_ret = (vector<CFiller>*) Mtolua_new((vector<CFiller>)());
1424 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<CFiller>");
1425 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1426 }
1427 }
1428 return 1;
1429 #ifndef TOLUA_RELEASE
1430 tolua_lerror:
1431 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1432 return 0;
1433 #endif
1434 }
1435 #endif //#ifndef TOLUA_DISABLE
1436
1437 /* method: delete of class vector<CFiller> */
1438 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__delete00
1439 static int tolua_stratagus_vector_CFiller__delete00(lua_State* tolua_S)
1440 {
1441 #ifndef TOLUA_RELEASE
1442 tolua_Error tolua_err;
1443 if (
1444 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1445 !tolua_isnoobj(tolua_S,2,&tolua_err)
1446 )
1447 goto tolua_lerror;
1448 else
1449 #endif
1450 {
1451 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1452 #ifndef TOLUA_RELEASE
1453 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
1454 #endif
1455 Mtolua_delete(self);
1456 }
1457 return 0;
1458 #ifndef TOLUA_RELEASE
1459 tolua_lerror:
1460 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
1461 return 0;
1462 #endif
1463 }
1464 #endif //#ifndef TOLUA_DISABLE
1465
1466 /* method: operator[] of class vector<CFiller> */
1467 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller___geti00
1468 static int tolua_stratagus_vector_CFiller___geti00(lua_State* tolua_S)
1469 {
1470 #ifndef TOLUA_RELEASE
1471 tolua_Error tolua_err;
1472 if (
1473 !tolua_isusertype(tolua_S,1,"const vector<CFiller>",0,&tolua_err) ||
1474 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1475 !tolua_isnoobj(tolua_S,3,&tolua_err)
1476 )
1477 goto tolua_lerror;
1478 else
1479 #endif
1480 {
1481 const vector<CFiller>* self = (const vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1482 int index = ((int) tolua_tonumber(tolua_S,2,0));
1483 #ifndef TOLUA_RELEASE
1484 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
1485 #endif
1486 {
1487 const CFiller tolua_ret = (const CFiller) self->operator[](index);
1488 {
1489 #ifdef __cplusplus
1490 void* tolua_obj = Mtolua_new((CFiller)(tolua_ret));
1491 tolua_pushusertype(tolua_S,tolua_obj,"const CFiller");
1492 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1493 #else
1494 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const CFiller));
1495 tolua_pushusertype(tolua_S,tolua_obj,"const CFiller");
1496 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1497 #endif
1498 }
1499 }
1500 }
1501 return 1;
1502 #ifndef TOLUA_RELEASE
1503 tolua_lerror:
1504 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
1505 return 0;
1506 #endif
1507 }
1508 #endif //#ifndef TOLUA_DISABLE
1509
1510 /* method: operator&[] of class vector<CFiller> */
1511 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller___seti00
1512 static int tolua_stratagus_vector_CFiller___seti00(lua_State* tolua_S)
1513 {
1514 #ifndef TOLUA_RELEASE
1515 tolua_Error tolua_err;
1516 if (
1517 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1518 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1519 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"CFiller",0,&tolua_err)) ||
1520 !tolua_isnoobj(tolua_S,4,&tolua_err)
1521 )
1522 goto tolua_lerror;
1523 else
1524 #endif
1525 {
1526 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1527 int index = ((int) tolua_tonumber(tolua_S,2,0));
1528 CFiller tolua_value = *((CFiller*) tolua_tousertype(tolua_S,3,0));
1529 #ifndef TOLUA_RELEASE
1530 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
1531 #endif
1532 self->operator[](index) = tolua_value;
1533 }
1534 return 0;
1535 #ifndef TOLUA_RELEASE
1536 tolua_lerror:
1537 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
1538 return 0;
1539 #endif
1540 }
1541 #endif //#ifndef TOLUA_DISABLE
1542
1543 /* method: operator[] of class vector<CFiller> */
1544 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller___geti01
1545 static int tolua_stratagus_vector_CFiller___geti01(lua_State* tolua_S)
1546 {
1547 tolua_Error tolua_err;
1548 if (
1549 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1550 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1551 !tolua_isnoobj(tolua_S,3,&tolua_err)
1552 )
1553 goto tolua_lerror;
1554 else
1555 {
1556 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1557 int index = ((int) tolua_tonumber(tolua_S,2,0));
1558 #ifndef TOLUA_RELEASE
1559 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
1560 #endif
1561 {
1562 CFiller tolua_ret = (CFiller) self->operator[](index);
1563 {
1564 #ifdef __cplusplus
1565 void* tolua_obj = Mtolua_new((CFiller)(tolua_ret));
1566 tolua_pushusertype(tolua_S,tolua_obj,"CFiller");
1567 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1568 #else
1569 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CFiller));
1570 tolua_pushusertype(tolua_S,tolua_obj,"CFiller");
1571 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1572 #endif
1573 }
1574 }
1575 }
1576 return 1;
1577 tolua_lerror:
1578 return tolua_stratagus_vector_CFiller___geti00(tolua_S);
1579 }
1580 #endif //#ifndef TOLUA_DISABLE
1581
1582 /* method: at of class vector<CFiller> */
1583 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__at00
1584 static int tolua_stratagus_vector_CFiller__at00(lua_State* tolua_S)
1585 {
1586 #ifndef TOLUA_RELEASE
1587 tolua_Error tolua_err;
1588 if (
1589 !tolua_isusertype(tolua_S,1,"const vector<CFiller>",0,&tolua_err) ||
1590 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1591 !tolua_isnoobj(tolua_S,3,&tolua_err)
1592 )
1593 goto tolua_lerror;
1594 else
1595 #endif
1596 {
1597 const vector<CFiller>* self = (const vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1598 int index = ((int) tolua_tonumber(tolua_S,2,0));
1599 #ifndef TOLUA_RELEASE
1600 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'at'", NULL);
1601 #endif
1602 {
1603 const CFiller& tolua_ret = (const CFiller&) self->at(index);
1604 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CFiller");
1605 }
1606 }
1607 return 1;
1608 #ifndef TOLUA_RELEASE
1609 tolua_lerror:
1610 tolua_error(tolua_S,"#ferror in function 'at'.",&tolua_err);
1611 return 0;
1612 #endif
1613 }
1614 #endif //#ifndef TOLUA_DISABLE
1615
1616 /* method: at of class vector<CFiller> */
1617 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__at01
1618 static int tolua_stratagus_vector_CFiller__at01(lua_State* tolua_S)
1619 {
1620 tolua_Error tolua_err;
1621 if (
1622 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1623 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1624 !tolua_isnoobj(tolua_S,3,&tolua_err)
1625 )
1626 goto tolua_lerror;
1627 else
1628 {
1629 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1630 int index = ((int) tolua_tonumber(tolua_S,2,0));
1631 #ifndef TOLUA_RELEASE
1632 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'at'", NULL);
1633 #endif
1634 {
1635 CFiller& tolua_ret = (CFiller&) self->at(index);
1636 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CFiller");
1637 }
1638 }
1639 return 1;
1640 tolua_lerror:
1641 return tolua_stratagus_vector_CFiller__at00(tolua_S);
1642 }
1643 #endif //#ifndef TOLUA_DISABLE
1644
1645 /* method: front of class vector<CFiller> */
1646 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__front00
1647 static int tolua_stratagus_vector_CFiller__front00(lua_State* tolua_S)
1648 {
1649 #ifndef TOLUA_RELEASE
1650 tolua_Error tolua_err;
1651 if (
1652 !tolua_isusertype(tolua_S,1,"const vector<CFiller>",0,&tolua_err) ||
1653 !tolua_isnoobj(tolua_S,2,&tolua_err)
1654 )
1655 goto tolua_lerror;
1656 else
1657 #endif
1658 {
1659 const vector<CFiller>* self = (const vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1660 #ifndef TOLUA_RELEASE
1661 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'front'", NULL);
1662 #endif
1663 {
1664 const CFiller& tolua_ret = (const CFiller&) self->front();
1665 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CFiller");
1666 }
1667 }
1668 return 1;
1669 #ifndef TOLUA_RELEASE
1670 tolua_lerror:
1671 tolua_error(tolua_S,"#ferror in function 'front'.",&tolua_err);
1672 return 0;
1673 #endif
1674 }
1675 #endif //#ifndef TOLUA_DISABLE
1676
1677 /* method: front of class vector<CFiller> */
1678 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__front01
1679 static int tolua_stratagus_vector_CFiller__front01(lua_State* tolua_S)
1680 {
1681 tolua_Error tolua_err;
1682 if (
1683 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1684 !tolua_isnoobj(tolua_S,2,&tolua_err)
1685 )
1686 goto tolua_lerror;
1687 else
1688 {
1689 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1690 #ifndef TOLUA_RELEASE
1691 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'front'", NULL);
1692 #endif
1693 {
1694 CFiller& tolua_ret = (CFiller&) self->front();
1695 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CFiller");
1696 }
1697 }
1698 return 1;
1699 tolua_lerror:
1700 return tolua_stratagus_vector_CFiller__front00(tolua_S);
1701 }
1702 #endif //#ifndef TOLUA_DISABLE
1703
1704 /* method: back of class vector<CFiller> */
1705 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__back00
1706 static int tolua_stratagus_vector_CFiller__back00(lua_State* tolua_S)
1707 {
1708 #ifndef TOLUA_RELEASE
1709 tolua_Error tolua_err;
1710 if (
1711 !tolua_isusertype(tolua_S,1,"const vector<CFiller>",0,&tolua_err) ||
1712 !tolua_isnoobj(tolua_S,2,&tolua_err)
1713 )
1714 goto tolua_lerror;
1715 else
1716 #endif
1717 {
1718 const vector<CFiller>* self = (const vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1719 #ifndef TOLUA_RELEASE
1720 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
1721 #endif
1722 {
1723 const CFiller& tolua_ret = (const CFiller&) self->back();
1724 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CFiller");
1725 }
1726 }
1727 return 1;
1728 #ifndef TOLUA_RELEASE
1729 tolua_lerror:
1730 tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
1731 return 0;
1732 #endif
1733 }
1734 #endif //#ifndef TOLUA_DISABLE
1735
1736 /* method: back of class vector<CFiller> */
1737 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__back01
1738 static int tolua_stratagus_vector_CFiller__back01(lua_State* tolua_S)
1739 {
1740 tolua_Error tolua_err;
1741 if (
1742 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1743 !tolua_isnoobj(tolua_S,2,&tolua_err)
1744 )
1745 goto tolua_lerror;
1746 else
1747 {
1748 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1749 #ifndef TOLUA_RELEASE
1750 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
1751 #endif
1752 {
1753 CFiller& tolua_ret = (CFiller&) self->back();
1754 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CFiller");
1755 }
1756 }
1757 return 1;
1758 tolua_lerror:
1759 return tolua_stratagus_vector_CFiller__back00(tolua_S);
1760 }
1761 #endif //#ifndef TOLUA_DISABLE
1762
1763 /* method: push_back of class vector<CFiller> */
1764 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__push_back00
1765 static int tolua_stratagus_vector_CFiller__push_back00(lua_State* tolua_S)
1766 {
1767 #ifndef TOLUA_RELEASE
1768 tolua_Error tolua_err;
1769 if (
1770 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1771 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CFiller",0,&tolua_err)) ||
1772 !tolua_isnoobj(tolua_S,3,&tolua_err)
1773 )
1774 goto tolua_lerror;
1775 else
1776 #endif
1777 {
1778 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1779 CFiller val = *((CFiller*) tolua_tousertype(tolua_S,2,0));
1780 #ifndef TOLUA_RELEASE
1781 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
1782 #endif
1783 {
1784 self->push_back(val);
1785 }
1786 }
1787 return 0;
1788 #ifndef TOLUA_RELEASE
1789 tolua_lerror:
1790 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
1791 return 0;
1792 #endif
1793 }
1794 #endif //#ifndef TOLUA_DISABLE
1795
1796 /* method: pop_back of class vector<CFiller> */
1797 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__pop_back00
1798 static int tolua_stratagus_vector_CFiller__pop_back00(lua_State* tolua_S)
1799 {
1800 #ifndef TOLUA_RELEASE
1801 tolua_Error tolua_err;
1802 if (
1803 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1804 !tolua_isnoobj(tolua_S,2,&tolua_err)
1805 )
1806 goto tolua_lerror;
1807 else
1808 #endif
1809 {
1810 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1811 #ifndef TOLUA_RELEASE
1812 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pop_back'", NULL);
1813 #endif
1814 {
1815 self->pop_back();
1816 }
1817 }
1818 return 0;
1819 #ifndef TOLUA_RELEASE
1820 tolua_lerror:
1821 tolua_error(tolua_S,"#ferror in function 'pop_back'.",&tolua_err);
1822 return 0;
1823 #endif
1824 }
1825 #endif //#ifndef TOLUA_DISABLE
1826
1827 /* method: assign of class vector<CFiller> */
1828 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__assign00
1829 static int tolua_stratagus_vector_CFiller__assign00(lua_State* tolua_S)
1830 {
1831 #ifndef TOLUA_RELEASE
1832 tolua_Error tolua_err;
1833 if (
1834 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1835 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1836 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const CFiller",0,&tolua_err)) ||
1837 !tolua_isnoobj(tolua_S,4,&tolua_err)
1838 )
1839 goto tolua_lerror;
1840 else
1841 #endif
1842 {
1843 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1844 int num = ((int) tolua_tonumber(tolua_S,2,0));
1845 const CFiller* val = ((const CFiller*) tolua_tousertype(tolua_S,3,0));
1846 #ifndef TOLUA_RELEASE
1847 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'assign'", NULL);
1848 #endif
1849 {
1850 self->assign(num,*val);
1851 }
1852 }
1853 return 0;
1854 #ifndef TOLUA_RELEASE
1855 tolua_lerror:
1856 tolua_error(tolua_S,"#ferror in function 'assign'.",&tolua_err);
1857 return 0;
1858 #endif
1859 }
1860 #endif //#ifndef TOLUA_DISABLE
1861
1862 /* method: clear of class vector<CFiller> */
1863 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__clear00
1864 static int tolua_stratagus_vector_CFiller__clear00(lua_State* tolua_S)
1865 {
1866 #ifndef TOLUA_RELEASE
1867 tolua_Error tolua_err;
1868 if (
1869 !tolua_isusertype(tolua_S,1,"vector<CFiller>",0,&tolua_err) ||
1870 !tolua_isnoobj(tolua_S,2,&tolua_err)
1871 )
1872 goto tolua_lerror;
1873 else
1874 #endif
1875 {
1876 vector<CFiller>* self = (vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1877 #ifndef TOLUA_RELEASE
1878 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
1879 #endif
1880 {
1881 self->clear();
1882 }
1883 }
1884 return 0;
1885 #ifndef TOLUA_RELEASE
1886 tolua_lerror:
1887 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
1888 return 0;
1889 #endif
1890 }
1891 #endif //#ifndef TOLUA_DISABLE
1892
1893 /* method: empty of class vector<CFiller> */
1894 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__empty00
1895 static int tolua_stratagus_vector_CFiller__empty00(lua_State* tolua_S)
1896 {
1897 #ifndef TOLUA_RELEASE
1898 tolua_Error tolua_err;
1899 if (
1900 !tolua_isusertype(tolua_S,1,"const vector<CFiller>",0,&tolua_err) ||
1901 !tolua_isnoobj(tolua_S,2,&tolua_err)
1902 )
1903 goto tolua_lerror;
1904 else
1905 #endif
1906 {
1907 const vector<CFiller>* self = (const vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1908 #ifndef TOLUA_RELEASE
1909 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'empty'", NULL);
1910 #endif
1911 {
1912 bool tolua_ret = (bool) self->empty();
1913 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1914 }
1915 }
1916 return 1;
1917 #ifndef TOLUA_RELEASE
1918 tolua_lerror:
1919 tolua_error(tolua_S,"#ferror in function 'empty'.",&tolua_err);
1920 return 0;
1921 #endif
1922 }
1923 #endif //#ifndef TOLUA_DISABLE
1924
1925 /* method: size of class vector<CFiller> */
1926 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CFiller__size00
1927 static int tolua_stratagus_vector_CFiller__size00(lua_State* tolua_S)
1928 {
1929 #ifndef TOLUA_RELEASE
1930 tolua_Error tolua_err;
1931 if (
1932 !tolua_isusertype(tolua_S,1,"const vector<CFiller>",0,&tolua_err) ||
1933 !tolua_isnoobj(tolua_S,2,&tolua_err)
1934 )
1935 goto tolua_lerror;
1936 else
1937 #endif
1938 {
1939 const vector<CFiller>* self = (const vector<CFiller>*) tolua_tousertype(tolua_S,1,0);
1940 #ifndef TOLUA_RELEASE
1941 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
1942 #endif
1943 {
1944 int tolua_ret = (int) self->size();
1945 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1946 }
1947 }
1948 return 1;
1949 #ifndef TOLUA_RELEASE
1950 tolua_lerror:
1951 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
1952 return 0;
1953 #endif
1954 }
1955 #endif //#ifndef TOLUA_DISABLE
1956
1957 /* method: new of class vector<CUIButton> */
1958 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__new00
1959 static int tolua_stratagus_vector_CUIButton__new00(lua_State* tolua_S)
1960 {
1961 #ifndef TOLUA_RELEASE
1962 tolua_Error tolua_err;
1963 if (
1964 !tolua_isusertable(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
1965 !tolua_isnoobj(tolua_S,2,&tolua_err)
1966 )
1967 goto tolua_lerror;
1968 else
1969 #endif
1970 {
1971 {
1972 vector<CUIButton>* tolua_ret = (vector<CUIButton>*) Mtolua_new((vector<CUIButton>)());
1973 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<CUIButton>");
1974 }
1975 }
1976 return 1;
1977 #ifndef TOLUA_RELEASE
1978 tolua_lerror:
1979 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1980 return 0;
1981 #endif
1982 }
1983 #endif //#ifndef TOLUA_DISABLE
1984
1985 /* method: new_local of class vector<CUIButton> */
1986 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__new00_local
1987 static int tolua_stratagus_vector_CUIButton__new00_local(lua_State* tolua_S)
1988 {
1989 #ifndef TOLUA_RELEASE
1990 tolua_Error tolua_err;
1991 if (
1992 !tolua_isusertable(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
1993 !tolua_isnoobj(tolua_S,2,&tolua_err)
1994 )
1995 goto tolua_lerror;
1996 else
1997 #endif
1998 {
1999 {
2000 vector<CUIButton>* tolua_ret = (vector<CUIButton>*) Mtolua_new((vector<CUIButton>)());
2001 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<CUIButton>");
2002 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2003 }
2004 }
2005 return 1;
2006 #ifndef TOLUA_RELEASE
2007 tolua_lerror:
2008 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
2009 return 0;
2010 #endif
2011 }
2012 #endif //#ifndef TOLUA_DISABLE
2013
2014 /* method: delete of class vector<CUIButton> */
2015 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__delete00
2016 static int tolua_stratagus_vector_CUIButton__delete00(lua_State* tolua_S)
2017 {
2018 #ifndef TOLUA_RELEASE
2019 tolua_Error tolua_err;
2020 if (
2021 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2022 !tolua_isnoobj(tolua_S,2,&tolua_err)
2023 )
2024 goto tolua_lerror;
2025 else
2026 #endif
2027 {
2028 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2029 #ifndef TOLUA_RELEASE
2030 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
2031 #endif
2032 Mtolua_delete(self);
2033 }
2034 return 0;
2035 #ifndef TOLUA_RELEASE
2036 tolua_lerror:
2037 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
2038 return 0;
2039 #endif
2040 }
2041 #endif //#ifndef TOLUA_DISABLE
2042
2043 /* method: operator[] of class vector<CUIButton> */
2044 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton___geti00
2045 static int tolua_stratagus_vector_CUIButton___geti00(lua_State* tolua_S)
2046 {
2047 #ifndef TOLUA_RELEASE
2048 tolua_Error tolua_err;
2049 if (
2050 !tolua_isusertype(tolua_S,1,"const vector<CUIButton>",0,&tolua_err) ||
2051 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2052 !tolua_isnoobj(tolua_S,3,&tolua_err)
2053 )
2054 goto tolua_lerror;
2055 else
2056 #endif
2057 {
2058 const vector<CUIButton>* self = (const vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2059 int index = ((int) tolua_tonumber(tolua_S,2,0));
2060 #ifndef TOLUA_RELEASE
2061 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
2062 #endif
2063 {
2064 const CUIButton tolua_ret = (const CUIButton) self->operator[](index);
2065 {
2066 #ifdef __cplusplus
2067 void* tolua_obj = Mtolua_new((CUIButton)(tolua_ret));
2068 tolua_pushusertype(tolua_S,tolua_obj,"const CUIButton");
2069 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2070 #else
2071 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const CUIButton));
2072 tolua_pushusertype(tolua_S,tolua_obj,"const CUIButton");
2073 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2074 #endif
2075 }
2076 }
2077 }
2078 return 1;
2079 #ifndef TOLUA_RELEASE
2080 tolua_lerror:
2081 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
2082 return 0;
2083 #endif
2084 }
2085 #endif //#ifndef TOLUA_DISABLE
2086
2087 /* method: operator&[] of class vector<CUIButton> */
2088 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton___seti00
2089 static int tolua_stratagus_vector_CUIButton___seti00(lua_State* tolua_S)
2090 {
2091 #ifndef TOLUA_RELEASE
2092 tolua_Error tolua_err;
2093 if (
2094 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2095 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2096 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"CUIButton",0,&tolua_err)) ||
2097 !tolua_isnoobj(tolua_S,4,&tolua_err)
2098 )
2099 goto tolua_lerror;
2100 else
2101 #endif
2102 {
2103 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2104 int index = ((int) tolua_tonumber(tolua_S,2,0));
2105 CUIButton tolua_value = *((CUIButton*) tolua_tousertype(tolua_S,3,0));
2106 #ifndef TOLUA_RELEASE
2107 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
2108 #endif
2109 self->operator[](index) = tolua_value;
2110 }
2111 return 0;
2112 #ifndef TOLUA_RELEASE
2113 tolua_lerror:
2114 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
2115 return 0;
2116 #endif
2117 }
2118 #endif //#ifndef TOLUA_DISABLE
2119
2120 /* method: operator[] of class vector<CUIButton> */
2121 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton___geti01
2122 static int tolua_stratagus_vector_CUIButton___geti01(lua_State* tolua_S)
2123 {
2124 tolua_Error tolua_err;
2125 if (
2126 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2127 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2128 !tolua_isnoobj(tolua_S,3,&tolua_err)
2129 )
2130 goto tolua_lerror;
2131 else
2132 {
2133 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2134 int index = ((int) tolua_tonumber(tolua_S,2,0));
2135 #ifndef TOLUA_RELEASE
2136 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
2137 #endif
2138 {
2139 CUIButton tolua_ret = (CUIButton) self->operator[](index);
2140 {
2141 #ifdef __cplusplus
2142 void* tolua_obj = Mtolua_new((CUIButton)(tolua_ret));
2143 tolua_pushusertype(tolua_S,tolua_obj,"CUIButton");
2144 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2145 #else
2146 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CUIButton));
2147 tolua_pushusertype(tolua_S,tolua_obj,"CUIButton");
2148 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2149 #endif
2150 }
2151 }
2152 }
2153 return 1;
2154 tolua_lerror:
2155 return tolua_stratagus_vector_CUIButton___geti00(tolua_S);
2156 }
2157 #endif //#ifndef TOLUA_DISABLE
2158
2159 /* method: at of class vector<CUIButton> */
2160 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__at00
2161 static int tolua_stratagus_vector_CUIButton__at00(lua_State* tolua_S)
2162 {
2163 #ifndef TOLUA_RELEASE
2164 tolua_Error tolua_err;
2165 if (
2166 !tolua_isusertype(tolua_S,1,"const vector<CUIButton>",0,&tolua_err) ||
2167 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2168 !tolua_isnoobj(tolua_S,3,&tolua_err)
2169 )
2170 goto tolua_lerror;
2171 else
2172 #endif
2173 {
2174 const vector<CUIButton>* self = (const vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2175 int index = ((int) tolua_tonumber(tolua_S,2,0));
2176 #ifndef TOLUA_RELEASE
2177 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'at'", NULL);
2178 #endif
2179 {
2180 const CUIButton& tolua_ret = (const CUIButton&) self->at(index);
2181 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CUIButton");
2182 }
2183 }
2184 return 1;
2185 #ifndef TOLUA_RELEASE
2186 tolua_lerror:
2187 tolua_error(tolua_S,"#ferror in function 'at'.",&tolua_err);
2188 return 0;
2189 #endif
2190 }
2191 #endif //#ifndef TOLUA_DISABLE
2192
2193 /* method: at of class vector<CUIButton> */
2194 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__at01
2195 static int tolua_stratagus_vector_CUIButton__at01(lua_State* tolua_S)
2196 {
2197 tolua_Error tolua_err;
2198 if (
2199 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2200 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2201 !tolua_isnoobj(tolua_S,3,&tolua_err)
2202 )
2203 goto tolua_lerror;
2204 else
2205 {
2206 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2207 int index = ((int) tolua_tonumber(tolua_S,2,0));
2208 #ifndef TOLUA_RELEASE
2209 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'at'", NULL);
2210 #endif
2211 {
2212 CUIButton& tolua_ret = (CUIButton&) self->at(index);
2213 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CUIButton");
2214 }
2215 }
2216 return 1;
2217 tolua_lerror:
2218 return tolua_stratagus_vector_CUIButton__at00(tolua_S);
2219 }
2220 #endif //#ifndef TOLUA_DISABLE
2221
2222 /* method: front of class vector<CUIButton> */
2223 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__front00
2224 static int tolua_stratagus_vector_CUIButton__front00(lua_State* tolua_S)
2225 {
2226 #ifndef TOLUA_RELEASE
2227 tolua_Error tolua_err;
2228 if (
2229 !tolua_isusertype(tolua_S,1,"const vector<CUIButton>",0,&tolua_err) ||
2230 !tolua_isnoobj(tolua_S,2,&tolua_err)
2231 )
2232 goto tolua_lerror;
2233 else
2234 #endif
2235 {
2236 const vector<CUIButton>* self = (const vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2237 #ifndef TOLUA_RELEASE
2238 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'front'", NULL);
2239 #endif
2240 {
2241 const CUIButton& tolua_ret = (const CUIButton&) self->front();
2242 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CUIButton");
2243 }
2244 }
2245 return 1;
2246 #ifndef TOLUA_RELEASE
2247 tolua_lerror:
2248 tolua_error(tolua_S,"#ferror in function 'front'.",&tolua_err);
2249 return 0;
2250 #endif
2251 }
2252 #endif //#ifndef TOLUA_DISABLE
2253
2254 /* method: front of class vector<CUIButton> */
2255 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__front01
2256 static int tolua_stratagus_vector_CUIButton__front01(lua_State* tolua_S)
2257 {
2258 tolua_Error tolua_err;
2259 if (
2260 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2261 !tolua_isnoobj(tolua_S,2,&tolua_err)
2262 )
2263 goto tolua_lerror;
2264 else
2265 {
2266 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2267 #ifndef TOLUA_RELEASE
2268 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'front'", NULL);
2269 #endif
2270 {
2271 CUIButton& tolua_ret = (CUIButton&) self->front();
2272 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CUIButton");
2273 }
2274 }
2275 return 1;
2276 tolua_lerror:
2277 return tolua_stratagus_vector_CUIButton__front00(tolua_S);
2278 }
2279 #endif //#ifndef TOLUA_DISABLE
2280
2281 /* method: back of class vector<CUIButton> */
2282 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__back00
2283 static int tolua_stratagus_vector_CUIButton__back00(lua_State* tolua_S)
2284 {
2285 #ifndef TOLUA_RELEASE
2286 tolua_Error tolua_err;
2287 if (
2288 !tolua_isusertype(tolua_S,1,"const vector<CUIButton>",0,&tolua_err) ||
2289 !tolua_isnoobj(tolua_S,2,&tolua_err)
2290 )
2291 goto tolua_lerror;
2292 else
2293 #endif
2294 {
2295 const vector<CUIButton>* self = (const vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2296 #ifndef TOLUA_RELEASE
2297 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
2298 #endif
2299 {
2300 const CUIButton& tolua_ret = (const CUIButton&) self->back();
2301 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CUIButton");
2302 }
2303 }
2304 return 1;
2305 #ifndef TOLUA_RELEASE
2306 tolua_lerror:
2307 tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
2308 return 0;
2309 #endif
2310 }
2311 #endif //#ifndef TOLUA_DISABLE
2312
2313 /* method: back of class vector<CUIButton> */
2314 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__back01
2315 static int tolua_stratagus_vector_CUIButton__back01(lua_State* tolua_S)
2316 {
2317 tolua_Error tolua_err;
2318 if (
2319 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2320 !tolua_isnoobj(tolua_S,2,&tolua_err)
2321 )
2322 goto tolua_lerror;
2323 else
2324 {
2325 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2326 #ifndef TOLUA_RELEASE
2327 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
2328 #endif
2329 {
2330 CUIButton& tolua_ret = (CUIButton&) self->back();
2331 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CUIButton");
2332 }
2333 }
2334 return 1;
2335 tolua_lerror:
2336 return tolua_stratagus_vector_CUIButton__back00(tolua_S);
2337 }
2338 #endif //#ifndef TOLUA_DISABLE
2339
2340 /* method: push_back of class vector<CUIButton> */
2341 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__push_back00
2342 static int tolua_stratagus_vector_CUIButton__push_back00(lua_State* tolua_S)
2343 {
2344 #ifndef TOLUA_RELEASE
2345 tolua_Error tolua_err;
2346 if (
2347 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2348 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CUIButton",0,&tolua_err)) ||
2349 !tolua_isnoobj(tolua_S,3,&tolua_err)
2350 )
2351 goto tolua_lerror;
2352 else
2353 #endif
2354 {
2355 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2356 CUIButton val = *((CUIButton*) tolua_tousertype(tolua_S,2,0));
2357 #ifndef TOLUA_RELEASE
2358 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
2359 #endif
2360 {
2361 self->push_back(val);
2362 }
2363 }
2364 return 0;
2365 #ifndef TOLUA_RELEASE
2366 tolua_lerror:
2367 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
2368 return 0;
2369 #endif
2370 }
2371 #endif //#ifndef TOLUA_DISABLE
2372
2373 /* method: pop_back of class vector<CUIButton> */
2374 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__pop_back00
2375 static int tolua_stratagus_vector_CUIButton__pop_back00(lua_State* tolua_S)
2376 {
2377 #ifndef TOLUA_RELEASE
2378 tolua_Error tolua_err;
2379 if (
2380 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2381 !tolua_isnoobj(tolua_S,2,&tolua_err)
2382 )
2383 goto tolua_lerror;
2384 else
2385 #endif
2386 {
2387 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2388 #ifndef TOLUA_RELEASE
2389 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pop_back'", NULL);
2390 #endif
2391 {
2392 self->pop_back();
2393 }
2394 }
2395 return 0;
2396 #ifndef TOLUA_RELEASE
2397 tolua_lerror:
2398 tolua_error(tolua_S,"#ferror in function 'pop_back'.",&tolua_err);
2399 return 0;
2400 #endif
2401 }
2402 #endif //#ifndef TOLUA_DISABLE
2403
2404 /* method: assign of class vector<CUIButton> */
2405 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__assign00
2406 static int tolua_stratagus_vector_CUIButton__assign00(lua_State* tolua_S)
2407 {
2408 #ifndef TOLUA_RELEASE
2409 tolua_Error tolua_err;
2410 if (
2411 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2412 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2413 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const CUIButton",0,&tolua_err)) ||
2414 !tolua_isnoobj(tolua_S,4,&tolua_err)
2415 )
2416 goto tolua_lerror;
2417 else
2418 #endif
2419 {
2420 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2421 int num = ((int) tolua_tonumber(tolua_S,2,0));
2422 const CUIButton* val = ((const CUIButton*) tolua_tousertype(tolua_S,3,0));
2423 #ifndef TOLUA_RELEASE
2424 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'assign'", NULL);
2425 #endif
2426 {
2427 self->assign(num,*val);
2428 }
2429 }
2430 return 0;
2431 #ifndef TOLUA_RELEASE
2432 tolua_lerror:
2433 tolua_error(tolua_S,"#ferror in function 'assign'.",&tolua_err);
2434 return 0;
2435 #endif
2436 }
2437 #endif //#ifndef TOLUA_DISABLE
2438
2439 /* method: clear of class vector<CUIButton> */
2440 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__clear00
2441 static int tolua_stratagus_vector_CUIButton__clear00(lua_State* tolua_S)
2442 {
2443 #ifndef TOLUA_RELEASE
2444 tolua_Error tolua_err;
2445 if (
2446 !tolua_isusertype(tolua_S,1,"vector<CUIButton>",0,&tolua_err) ||
2447 !tolua_isnoobj(tolua_S,2,&tolua_err)
2448 )
2449 goto tolua_lerror;
2450 else
2451 #endif
2452 {
2453 vector<CUIButton>* self = (vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2454 #ifndef TOLUA_RELEASE
2455 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
2456 #endif
2457 {
2458 self->clear();
2459 }
2460 }
2461 return 0;
2462 #ifndef TOLUA_RELEASE
2463 tolua_lerror:
2464 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
2465 return 0;
2466 #endif
2467 }
2468 #endif //#ifndef TOLUA_DISABLE
2469
2470 /* method: empty of class vector<CUIButton> */
2471 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__empty00
2472 static int tolua_stratagus_vector_CUIButton__empty00(lua_State* tolua_S)
2473 {
2474 #ifndef TOLUA_RELEASE
2475 tolua_Error tolua_err;
2476 if (
2477 !tolua_isusertype(tolua_S,1,"const vector<CUIButton>",0,&tolua_err) ||
2478 !tolua_isnoobj(tolua_S,2,&tolua_err)
2479 )
2480 goto tolua_lerror;
2481 else
2482 #endif
2483 {
2484 const vector<CUIButton>* self = (const vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2485 #ifndef TOLUA_RELEASE
2486 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'empty'", NULL);
2487 #endif
2488 {
2489 bool tolua_ret = (bool) self->empty();
2490 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2491 }
2492 }
2493 return 1;
2494 #ifndef TOLUA_RELEASE
2495 tolua_lerror:
2496 tolua_error(tolua_S,"#ferror in function 'empty'.",&tolua_err);
2497 return 0;
2498 #endif
2499 }
2500 #endif //#ifndef TOLUA_DISABLE
2501
2502 /* method: size of class vector<CUIButton> */
2503 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_CUIButton__size00
2504 static int tolua_stratagus_vector_CUIButton__size00(lua_State* tolua_S)
2505 {
2506 #ifndef TOLUA_RELEASE
2507 tolua_Error tolua_err;
2508 if (
2509 !tolua_isusertype(tolua_S,1,"const vector<CUIButton>",0,&tolua_err) ||
2510 !tolua_isnoobj(tolua_S,2,&tolua_err)
2511 )
2512 goto tolua_lerror;
2513 else
2514 #endif
2515 {
2516 const vector<CUIButton>* self = (const vector<CUIButton>*) tolua_tousertype(tolua_S,1,0);
2517 #ifndef TOLUA_RELEASE
2518 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
2519 #endif
2520 {
2521 int tolua_ret = (int) self->size();
2522 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2523 }
2524 }
2525 return 1;
2526 #ifndef TOLUA_RELEASE
2527 tolua_lerror:
2528 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
2529 return 0;
2530 #endif
2531 }
2532 #endif //#ifndef TOLUA_DISABLE
2533
2534 /* method: new of class vector<string> */
2535 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__new00
2536 static int tolua_stratagus_vector_string__new00(lua_State* tolua_S)
2537 {
2538 #ifndef TOLUA_RELEASE
2539 tolua_Error tolua_err;
2540 if (
2541 !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
2542 !tolua_isnoobj(tolua_S,2,&tolua_err)
2543 )
2544 goto tolua_lerror;
2545 else
2546 #endif
2547 {
2548 {
2549 vector<string>* tolua_ret = (vector<string>*) Mtolua_new((vector<string>)());
2550 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
2551 }
2552 }
2553 return 1;
2554 #ifndef TOLUA_RELEASE
2555 tolua_lerror:
2556 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
2557 return 0;
2558 #endif
2559 }
2560 #endif //#ifndef TOLUA_DISABLE
2561
2562 /* method: new_local of class vector<string> */
2563 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__new00_local
2564 static int tolua_stratagus_vector_string__new00_local(lua_State* tolua_S)
2565 {
2566 #ifndef TOLUA_RELEASE
2567 tolua_Error tolua_err;
2568 if (
2569 !tolua_isusertable(tolua_S,1,"vector<string>",0,&tolua_err) ||
2570 !tolua_isnoobj(tolua_S,2,&tolua_err)
2571 )
2572 goto tolua_lerror;
2573 else
2574 #endif
2575 {
2576 {
2577 vector<string>* tolua_ret = (vector<string>*) Mtolua_new((vector<string>)());
2578 tolua_pushusertype(tolua_S,(void*)tolua_ret,"vector<string>");
2579 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2580 }
2581 }
2582 return 1;
2583 #ifndef TOLUA_RELEASE
2584 tolua_lerror:
2585 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
2586 return 0;
2587 #endif
2588 }
2589 #endif //#ifndef TOLUA_DISABLE
2590
2591 /* method: delete of class vector<string> */
2592 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__delete00
2593 static int tolua_stratagus_vector_string__delete00(lua_State* tolua_S)
2594 {
2595 #ifndef TOLUA_RELEASE
2596 tolua_Error tolua_err;
2597 if (
2598 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
2599 !tolua_isnoobj(tolua_S,2,&tolua_err)
2600 )
2601 goto tolua_lerror;
2602 else
2603 #endif
2604 {
2605 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
2606 #ifndef TOLUA_RELEASE
2607 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
2608 #endif
2609 Mtolua_delete(self);
2610 }
2611 return 0;
2612 #ifndef TOLUA_RELEASE
2613 tolua_lerror:
2614 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
2615 return 0;
2616 #endif
2617 }
2618 #endif //#ifndef TOLUA_DISABLE
2619
2620 /* method: operator[] of class vector<string> */
2621 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string___geti00
2622 static int tolua_stratagus_vector_string___geti00(lua_State* tolua_S)
2623 {
2624 #ifndef TOLUA_RELEASE
2625 tolua_Error tolua_err;
2626 if (
2627 !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
2628 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2629 !tolua_isnoobj(tolua_S,3,&tolua_err)
2630 )
2631 goto tolua_lerror;
2632 else
2633 #endif
2634 {
2635 const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
2636 int index = ((int) tolua_tonumber(tolua_S,2,0));
2637 #ifndef TOLUA_RELEASE
2638 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
2639 #endif
2640 {
2641 const string tolua_ret = (const string) self->operator[](index);
2642 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
2643 }
2644 }
2645 return 1;
2646 #ifndef TOLUA_RELEASE
2647 tolua_lerror:
2648 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
2649 return 0;
2650 #endif
2651 }
2652 #endif //#ifndef TOLUA_DISABLE
2653
2654 /* method: operator&[] of class vector<string> */
2655 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string___seti00
2656 static int tolua_stratagus_vector_string___seti00(lua_State* tolua_S)
2657 {
2658 #ifndef TOLUA_RELEASE
2659 tolua_Error tolua_err;
2660 if (
2661 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
2662 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2663 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
2664 !tolua_isnoobj(tolua_S,4,&tolua_err)
2665 )
2666 goto tolua_lerror;
2667 else
2668 #endif
2669 {
2670 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
2671 int index = ((int) tolua_tonumber(tolua_S,2,0));
2672 string tolua_value = ((string) tolua_tocppstring(tolua_S,3,0));
2673 #ifndef TOLUA_RELEASE
2674 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
2675 #endif
2676 self->operator[](index) = tolua_value;
2677 }
2678 return 0;
2679 #ifndef TOLUA_RELEASE
2680 tolua_lerror:
2681 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
2682 return 0;
2683 #endif
2684 }
2685 #endif //#ifndef TOLUA_DISABLE
2686
2687 /* method: operator[] of class vector<string> */
2688 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string___geti01
2689 static int tolua_stratagus_vector_string___geti01(lua_State* tolua_S)
2690 {
2691 tolua_Error tolua_err;
2692 if (
2693 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
2694 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2695 !tolua_isnoobj(tolua_S,3,&tolua_err)
2696 )
2697 goto tolua_lerror;
2698 else
2699 {
2700 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
2701 int index = ((int) tolua_tonumber(tolua_S,2,0));
2702 #ifndef TOLUA_RELEASE
2703 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
2704 #endif
2705 {
2706 string tolua_ret = (string) self->operator[](index);
2707 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
2708 }
2709 }
2710 return 1;
2711 tolua_lerror:
2712 return tolua_stratagus_vector_string___geti00(tolua_S);
2713 }
2714 #endif //#ifndef TOLUA_DISABLE
2715
2716 /* method: at of class vector<string> */
2717 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__at00
2718 static int tolua_stratagus_vector_string__at00(lua_State* tolua_S)
2719 {
2720 #ifndef TOLUA_RELEASE
2721 tolua_Error tolua_err;
2722 if (
2723 !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
2724 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2725 !tolua_isnoobj(tolua_S,3,&tolua_err)
2726 )
2727 goto tolua_lerror;
2728 else
2729 #endif
2730 {
2731 const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
2732 int index = ((int) tolua_tonumber(tolua_S,2,0));
2733 #ifndef TOLUA_RELEASE
2734 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'at'", NULL);
2735 #endif
2736 {
2737 const string tolua_ret = (const string) self->at(index);
2738 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
2739 }
2740 }
2741 return 1;
2742 #ifndef TOLUA_RELEASE
2743 tolua_lerror:
2744 tolua_error(tolua_S,"#ferror in function 'at'.",&tolua_err);
2745 return 0;
2746 #endif
2747 }
2748 #endif //#ifndef TOLUA_DISABLE
2749
2750 /* method: at of class vector<string> */
2751 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__at01
2752 static int tolua_stratagus_vector_string__at01(lua_State* tolua_S)
2753 {
2754 tolua_Error tolua_err;
2755 if (
2756 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
2757 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2758 !tolua_isnoobj(tolua_S,3,&tolua_err)
2759 )
2760 goto tolua_lerror;
2761 else
2762 {
2763 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
2764 int index = ((int) tolua_tonumber(tolua_S,2,0));
2765 #ifndef TOLUA_RELEASE
2766 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'at'", NULL);
2767 #endif
2768 {
2769 string tolua_ret = (string) self->at(index);
2770 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
2771 }
2772 }
2773 return 1;
2774 tolua_lerror:
2775 return tolua_stratagus_vector_string__at00(tolua_S);
2776 }
2777 #endif //#ifndef TOLUA_DISABLE
2778
2779 /* method: front of class vector<string> */
2780 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__front00
2781 static int tolua_stratagus_vector_string__front00(lua_State* tolua_S)
2782 {
2783 #ifndef TOLUA_RELEASE
2784 tolua_Error tolua_err;
2785 if (
2786 !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
2787 !tolua_isnoobj(tolua_S,2,&tolua_err)
2788 )
2789 goto tolua_lerror;
2790 else
2791 #endif
2792 {
2793 const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
2794 #ifndef TOLUA_RELEASE
2795 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'front'", NULL);
2796 #endif
2797 {
2798 const string tolua_ret = (const string) self->front();
2799 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
2800 }
2801 }
2802 return 1;
2803 #ifndef TOLUA_RELEASE
2804 tolua_lerror:
2805 tolua_error(tolua_S,"#ferror in function 'front'.",&tolua_err);
2806 return 0;
2807 #endif
2808 }
2809 #endif //#ifndef TOLUA_DISABLE
2810
2811 /* method: front of class vector<string> */
2812 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__front01
2813 static int tolua_stratagus_vector_string__front01(lua_State* tolua_S)
2814 {
2815 tolua_Error tolua_err;
2816 if (
2817 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
2818 !tolua_isnoobj(tolua_S,2,&tolua_err)
2819 )
2820 goto tolua_lerror;
2821 else
2822 {
2823 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
2824 #ifndef TOLUA_RELEASE
2825 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'front'", NULL);
2826 #endif
2827 {
2828 string tolua_ret = (string) self->front();
2829 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
2830 }
2831 }
2832 return 1;
2833 tolua_lerror:
2834 return tolua_stratagus_vector_string__front00(tolua_S);
2835 }
2836 #endif //#ifndef TOLUA_DISABLE
2837
2838 /* method: back of class vector<string> */
2839 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__back00
2840 static int tolua_stratagus_vector_string__back00(lua_State* tolua_S)
2841 {
2842 #ifndef TOLUA_RELEASE
2843 tolua_Error tolua_err;
2844 if (
2845 !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
2846 !tolua_isnoobj(tolua_S,2,&tolua_err)
2847 )
2848 goto tolua_lerror;
2849 else
2850 #endif
2851 {
2852 const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
2853 #ifndef TOLUA_RELEASE
2854 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
2855 #endif
2856 {
2857 const string tolua_ret = (const string) self->back();
2858 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
2859 }
2860 }
2861 return 1;
2862 #ifndef TOLUA_RELEASE
2863 tolua_lerror:
2864 tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
2865 return 0;
2866 #endif
2867 }
2868 #endif //#ifndef TOLUA_DISABLE
2869
2870 /* method: back of class vector<string> */
2871 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__back01
2872 static int tolua_stratagus_vector_string__back01(lua_State* tolua_S)
2873 {
2874 tolua_Error tolua_err;
2875 if (
2876 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
2877 !tolua_isnoobj(tolua_S,2,&tolua_err)
2878 )
2879 goto tolua_lerror;
2880 else
2881 {
2882 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
2883 #ifndef TOLUA_RELEASE
2884 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
2885 #endif
2886 {
2887 string tolua_ret = (string) self->back();
2888 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
2889 }
2890 }
2891 return 1;
2892 tolua_lerror:
2893 return tolua_stratagus_vector_string__back00(tolua_S);
2894 }
2895 #endif //#ifndef TOLUA_DISABLE
2896
2897 /* method: push_back of class vector<string> */
2898 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__push_back00
2899 static int tolua_stratagus_vector_string__push_back00(lua_State* tolua_S)
2900 {
2901 #ifndef TOLUA_RELEASE
2902 tolua_Error tolua_err;
2903 if (
2904 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
2905 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
2906 !tolua_isnoobj(tolua_S,3,&tolua_err)
2907 )
2908 goto tolua_lerror;
2909 else
2910 #endif
2911 {
2912 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
2913 string val = ((string) tolua_tocppstring(tolua_S,2,0));
2914 #ifndef TOLUA_RELEASE
2915 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
2916 #endif
2917 {
2918 self->push_back(val);
2919 }
2920 }
2921 return 0;
2922 #ifndef TOLUA_RELEASE
2923 tolua_lerror:
2924 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
2925 return 0;
2926 #endif
2927 }
2928 #endif //#ifndef TOLUA_DISABLE
2929
2930 /* method: pop_back of class vector<string> */
2931 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__pop_back00
2932 static int tolua_stratagus_vector_string__pop_back00(lua_State* tolua_S)
2933 {
2934 #ifndef TOLUA_RELEASE
2935 tolua_Error tolua_err;
2936 if (
2937 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
2938 !tolua_isnoobj(tolua_S,2,&tolua_err)
2939 )
2940 goto tolua_lerror;
2941 else
2942 #endif
2943 {
2944 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
2945 #ifndef TOLUA_RELEASE
2946 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pop_back'", NULL);
2947 #endif
2948 {
2949 self->pop_back();
2950 }
2951 }
2952 return 0;
2953 #ifndef TOLUA_RELEASE
2954 tolua_lerror:
2955 tolua_error(tolua_S,"#ferror in function 'pop_back'.",&tolua_err);
2956 return 0;
2957 #endif
2958 }
2959 #endif //#ifndef TOLUA_DISABLE
2960
2961 /* method: assign of class vector<string> */
2962 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__assign00
2963 static int tolua_stratagus_vector_string__assign00(lua_State* tolua_S)
2964 {
2965 #ifndef TOLUA_RELEASE
2966 tolua_Error tolua_err;
2967 if (
2968 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
2969 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2970 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
2971 !tolua_isnoobj(tolua_S,4,&tolua_err)
2972 )
2973 goto tolua_lerror;
2974 else
2975 #endif
2976 {
2977 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
2978 int num = ((int) tolua_tonumber(tolua_S,2,0));
2979 const string val = ((const string) tolua_tocppstring(tolua_S,3,0));
2980 #ifndef TOLUA_RELEASE
2981 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'assign'", NULL);
2982 #endif
2983 {
2984 self->assign(num,val);
2985 tolua_pushcppstring(tolua_S,(const char*)val);
2986 }
2987 }
2988 return 1;
2989 #ifndef TOLUA_RELEASE
2990 tolua_lerror:
2991 tolua_error(tolua_S,"#ferror in function 'assign'.",&tolua_err);
2992 return 0;
2993 #endif
2994 }
2995 #endif //#ifndef TOLUA_DISABLE
2996
2997 /* method: clear of class vector<string> */
2998 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__clear00
2999 static int tolua_stratagus_vector_string__clear00(lua_State* tolua_S)
3000 {
3001 #ifndef TOLUA_RELEASE
3002 tolua_Error tolua_err;
3003 if (
3004 !tolua_isusertype(tolua_S,1,"vector<string>",0,&tolua_err) ||
3005 !tolua_isnoobj(tolua_S,2,&tolua_err)
3006 )
3007 goto tolua_lerror;
3008 else
3009 #endif
3010 {
3011 vector<string>* self = (vector<string>*) tolua_tousertype(tolua_S,1,0);
3012 #ifndef TOLUA_RELEASE
3013 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
3014 #endif
3015 {
3016 self->clear();
3017 }
3018 }
3019 return 0;
3020 #ifndef TOLUA_RELEASE
3021 tolua_lerror:
3022 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
3023 return 0;
3024 #endif
3025 }
3026 #endif //#ifndef TOLUA_DISABLE
3027
3028 /* method: empty of class vector<string> */
3029 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__empty00
3030 static int tolua_stratagus_vector_string__empty00(lua_State* tolua_S)
3031 {
3032 #ifndef TOLUA_RELEASE
3033 tolua_Error tolua_err;
3034 if (
3035 !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
3036 !tolua_isnoobj(tolua_S,2,&tolua_err)
3037 )
3038 goto tolua_lerror;
3039 else
3040 #endif
3041 {
3042 const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
3043 #ifndef TOLUA_RELEASE
3044 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'empty'", NULL);
3045 #endif
3046 {
3047 bool tolua_ret = (bool) self->empty();
3048 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3049 }
3050 }
3051 return 1;
3052 #ifndef TOLUA_RELEASE
3053 tolua_lerror:
3054 tolua_error(tolua_S,"#ferror in function 'empty'.",&tolua_err);
3055 return 0;
3056 #endif
3057 }
3058 #endif //#ifndef TOLUA_DISABLE
3059
3060 /* method: size of class vector<string> */
3061 #ifndef TOLUA_DISABLE_tolua_stratagus_vector_string__size00
3062 static int tolua_stratagus_vector_string__size00(lua_State* tolua_S)
3063 {
3064 #ifndef TOLUA_RELEASE
3065 tolua_Error tolua_err;
3066 if (
3067 !tolua_isusertype(tolua_S,1,"const vector<string>",0,&tolua_err) ||
3068 !tolua_isnoobj(tolua_S,2,&tolua_err)
3069 )
3070 goto tolua_lerror;
3071 else
3072 #endif
3073 {
3074 const vector<string>* self = (const vector<string>*) tolua_tousertype(tolua_S,1,0);
3075 #ifndef TOLUA_RELEASE
3076 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
3077 #endif
3078 {
3079 int tolua_ret = (int) self->size();
3080 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
3081 }
3082 }
3083 return 1;
3084 #ifndef TOLUA_RELEASE
3085 tolua_lerror:
3086 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
3087 return 0;
3088 #endif
3089 }
3090 #endif //#ifndef TOLUA_DISABLE
3091
3092 /* get function: X of class CButtonPanel */
3093 #ifndef TOLUA_DISABLE_tolua_get_CButtonPanel_X
3094 static int tolua_get_CButtonPanel_X(lua_State* tolua_S)
3095 {
3096 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3097 #ifndef TOLUA_RELEASE
3098 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
3099 #endif
3100 tolua_pushnumber(tolua_S,(lua_Number)self->X);
3101 return 1;
3102 }
3103 #endif //#ifndef TOLUA_DISABLE
3104
3105 /* set function: X of class CButtonPanel */
3106 #ifndef TOLUA_DISABLE_tolua_set_CButtonPanel_X
3107 static int tolua_set_CButtonPanel_X(lua_State* tolua_S)
3108 {
3109 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3110 #ifndef TOLUA_RELEASE
3111 tolua_Error tolua_err;
3112 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
3113 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3114 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3115 #endif
3116 self->X = ((int) tolua_tonumber(tolua_S,2,0))
3117 ;
3118 return 0;
3119 }
3120 #endif //#ifndef TOLUA_DISABLE
3121
3122 /* get function: Y of class CButtonPanel */
3123 #ifndef TOLUA_DISABLE_tolua_get_CButtonPanel_Y
3124 static int tolua_get_CButtonPanel_Y(lua_State* tolua_S)
3125 {
3126 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3127 #ifndef TOLUA_RELEASE
3128 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
3129 #endif
3130 tolua_pushnumber(tolua_S,(lua_Number)self->Y);
3131 return 1;
3132 }
3133 #endif //#ifndef TOLUA_DISABLE
3134
3135 /* set function: Y of class CButtonPanel */
3136 #ifndef TOLUA_DISABLE_tolua_set_CButtonPanel_Y
3137 static int tolua_set_CButtonPanel_Y(lua_State* tolua_S)
3138 {
3139 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3140 #ifndef TOLUA_RELEASE
3141 tolua_Error tolua_err;
3142 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
3143 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3144 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3145 #endif
3146 self->Y = ((int) tolua_tonumber(tolua_S,2,0))
3147 ;
3148 return 0;
3149 }
3150 #endif //#ifndef TOLUA_DISABLE
3151
3152 /* get function: Buttons of class CButtonPanel */
3153 #ifndef TOLUA_DISABLE_tolua_get_CButtonPanel_Buttons
3154 static int tolua_get_CButtonPanel_Buttons(lua_State* tolua_S)
3155 {
3156 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3157 #ifndef TOLUA_RELEASE
3158 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Buttons'",NULL);
3159 #endif
3160 tolua_pushusertype(tolua_S,(void*)&self->Buttons,"vector<CUIButton>");
3161 return 1;
3162 }
3163 #endif //#ifndef TOLUA_DISABLE
3164
3165 /* set function: Buttons of class CButtonPanel */
3166 #ifndef TOLUA_DISABLE_tolua_set_CButtonPanel_Buttons
3167 static int tolua_set_CButtonPanel_Buttons(lua_State* tolua_S)
3168 {
3169 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3170 #ifndef TOLUA_RELEASE
3171 tolua_Error tolua_err;
3172 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Buttons'",NULL);
3173 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<CUIButton>",0,&tolua_err)))
3174 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3175 #endif
3176 self->Buttons = *((vector<CUIButton>*) tolua_tousertype(tolua_S,2,0))
3177 ;
3178 return 0;
3179 }
3180 #endif //#ifndef TOLUA_DISABLE
3181
3182 /* get function: AutoCastBorderColorRGB of class CButtonPanel */
3183 #ifndef TOLUA_DISABLE_tolua_get_CButtonPanel_AutoCastBorderColorRGB
3184 static int tolua_get_CButtonPanel_AutoCastBorderColorRGB(lua_State* tolua_S)
3185 {
3186 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3187 #ifndef TOLUA_RELEASE
3188 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AutoCastBorderColorRGB'",NULL);
3189 #endif
3190 tolua_pushusertype(tolua_S,(void*)&self->AutoCastBorderColorRGB,"CColor");
3191 return 1;
3192 }
3193 #endif //#ifndef TOLUA_DISABLE
3194
3195 /* set function: AutoCastBorderColorRGB of class CButtonPanel */
3196 #ifndef TOLUA_DISABLE_tolua_set_CButtonPanel_AutoCastBorderColorRGB
3197 static int tolua_set_CButtonPanel_AutoCastBorderColorRGB(lua_State* tolua_S)
3198 {
3199 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3200 #ifndef TOLUA_RELEASE
3201 tolua_Error tolua_err;
3202 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AutoCastBorderColorRGB'",NULL);
3203 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CColor",0,&tolua_err)))
3204 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3205 #endif
3206 self->AutoCastBorderColorRGB = *((CColor*) tolua_tousertype(tolua_S,2,0))
3207 ;
3208 return 0;
3209 }
3210 #endif //#ifndef TOLUA_DISABLE
3211
3212 /* get function: ShowCommandKey of class CButtonPanel */
3213 #ifndef TOLUA_DISABLE_tolua_get_CButtonPanel_ShowCommandKey
3214 static int tolua_get_CButtonPanel_ShowCommandKey(lua_State* tolua_S)
3215 {
3216 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3217 #ifndef TOLUA_RELEASE
3218 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowCommandKey'",NULL);
3219 #endif
3220 tolua_pushboolean(tolua_S,(bool)self->ShowCommandKey);
3221 return 1;
3222 }
3223 #endif //#ifndef TOLUA_DISABLE
3224
3225 /* set function: ShowCommandKey of class CButtonPanel */
3226 #ifndef TOLUA_DISABLE_tolua_set_CButtonPanel_ShowCommandKey
3227 static int tolua_set_CButtonPanel_ShowCommandKey(lua_State* tolua_S)
3228 {
3229 CButtonPanel* self = (CButtonPanel*) tolua_tousertype(tolua_S,1,0);
3230 #ifndef TOLUA_RELEASE
3231 tolua_Error tolua_err;
3232 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowCommandKey'",NULL);
3233 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
3234 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3235 #endif
3236 self->ShowCommandKey = ((bool) tolua_toboolean(tolua_S,2,0))
3237 ;
3238 return 0;
3239 }
3240 #endif //#ifndef TOLUA_DISABLE
3241
3242 /* get function: G of class CPieMenu */
3243 #ifndef TOLUA_DISABLE_tolua_get_CPieMenu_G_ptr
3244 static int tolua_get_CPieMenu_G_ptr(lua_State* tolua_S)
3245 {
3246 CPieMenu* self = (CPieMenu*) tolua_tousertype(tolua_S,1,0);
3247 #ifndef TOLUA_RELEASE
3248 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
3249 #endif
3250 tolua_pushusertype(tolua_S,(void*)self->G,"CGraphic");
3251 return 1;
3252 }
3253 #endif //#ifndef TOLUA_DISABLE
3254
3255 /* set function: G of class CPieMenu */
3256 #ifndef TOLUA_DISABLE_tolua_set_CPieMenu_G_ptr
3257 static int tolua_set_CPieMenu_G_ptr(lua_State* tolua_S)
3258 {
3259 CPieMenu* self = (CPieMenu*) tolua_tousertype(tolua_S,1,0);
3260 #ifndef TOLUA_RELEASE
3261 tolua_Error tolua_err;
3262 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
3263 if (!tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err))
3264 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3265 #endif
3266 self->G = ((CGraphic*) tolua_tousertype(tolua_S,2,0))
3267 ;
3268 return 0;
3269 }
3270 #endif //#ifndef TOLUA_DISABLE
3271
3272 /* get function: MouseButton of class CPieMenu */
3273 #ifndef TOLUA_DISABLE_tolua_get_CPieMenu_MouseButton
3274 static int tolua_get_CPieMenu_MouseButton(lua_State* tolua_S)
3275 {
3276 CPieMenu* self = (CPieMenu*) tolua_tousertype(tolua_S,1,0);
3277 #ifndef TOLUA_RELEASE
3278 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MouseButton'",NULL);
3279 #endif
3280 tolua_pushnumber(tolua_S,(lua_Number)self->MouseButton);
3281 return 1;
3282 }
3283 #endif //#ifndef TOLUA_DISABLE
3284
3285 /* set function: MouseButton of class CPieMenu */
3286 #ifndef TOLUA_DISABLE_tolua_set_CPieMenu_MouseButton
3287 static int tolua_set_CPieMenu_MouseButton(lua_State* tolua_S)
3288 {
3289 CPieMenu* self = (CPieMenu*) tolua_tousertype(tolua_S,1,0);
3290 #ifndef TOLUA_RELEASE
3291 tolua_Error tolua_err;
3292 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MouseButton'",NULL);
3293 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3294 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3295 #endif
3296 self->MouseButton = ((int) tolua_tonumber(tolua_S,2,0))
3297 ;
3298 return 0;
3299 }
3300 #endif //#ifndef TOLUA_DISABLE
3301
3302 /* get function: X of class CPieMenu */
3303 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CPieMenu_X
3304 static int tolua_get_stratagus_CPieMenu_X(lua_State* tolua_S)
3305 {
3306 int tolua_index;
3307 CPieMenu* self;
3308 lua_pushstring(tolua_S,".self");
3309 lua_rawget(tolua_S,1);
3310 self = (CPieMenu*) lua_touserdata(tolua_S,-1);
3311 #ifndef TOLUA_RELEASE
3312 {
3313 tolua_Error tolua_err;
3314 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3315 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3316 }
3317 #endif
3318 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3319 #ifndef TOLUA_RELEASE
3320 if (tolua_index<0 || tolua_index>=8)
3321 tolua_error(tolua_S,"array indexing out of range.",NULL);
3322 #endif
3323 tolua_pushnumber(tolua_S,(lua_Number)self->X[tolua_index]);
3324 return 1;
3325 }
3326 #endif //#ifndef TOLUA_DISABLE
3327
3328 /* set function: X of class CPieMenu */
3329 #ifndef TOLUA_DISABLE_tolua_set_stratagus_CPieMenu_X
3330 static int tolua_set_stratagus_CPieMenu_X(lua_State* tolua_S)
3331 {
3332 int tolua_index;
3333 CPieMenu* self;
3334 lua_pushstring(tolua_S,".self");
3335 lua_rawget(tolua_S,1);
3336 self = (CPieMenu*) lua_touserdata(tolua_S,-1);
3337 #ifndef TOLUA_RELEASE
3338 {
3339 tolua_Error tolua_err;
3340 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3341 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3342 }
3343 #endif
3344 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3345 #ifndef TOLUA_RELEASE
3346 if (tolua_index<0 || tolua_index>=8)
3347 tolua_error(tolua_S,"array indexing out of range.",NULL);
3348 #endif
3349 self->X[tolua_index] = ((int) tolua_tonumber(tolua_S,3,0));
3350 return 0;
3351 }
3352 #endif //#ifndef TOLUA_DISABLE
3353
3354 /* get function: Y of class CPieMenu */
3355 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CPieMenu_Y
3356 static int tolua_get_stratagus_CPieMenu_Y(lua_State* tolua_S)
3357 {
3358 int tolua_index;
3359 CPieMenu* self;
3360 lua_pushstring(tolua_S,".self");
3361 lua_rawget(tolua_S,1);
3362 self = (CPieMenu*) lua_touserdata(tolua_S,-1);
3363 #ifndef TOLUA_RELEASE
3364 {
3365 tolua_Error tolua_err;
3366 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3367 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3368 }
3369 #endif
3370 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3371 #ifndef TOLUA_RELEASE
3372 if (tolua_index<0 || tolua_index>=8)
3373 tolua_error(tolua_S,"array indexing out of range.",NULL);
3374 #endif
3375 tolua_pushnumber(tolua_S,(lua_Number)self->Y[tolua_index]);
3376 return 1;
3377 }
3378 #endif //#ifndef TOLUA_DISABLE
3379
3380 /* set function: Y of class CPieMenu */
3381 #ifndef TOLUA_DISABLE_tolua_set_stratagus_CPieMenu_Y
3382 static int tolua_set_stratagus_CPieMenu_Y(lua_State* tolua_S)
3383 {
3384 int tolua_index;
3385 CPieMenu* self;
3386 lua_pushstring(tolua_S,".self");
3387 lua_rawget(tolua_S,1);
3388 self = (CPieMenu*) lua_touserdata(tolua_S,-1);
3389 #ifndef TOLUA_RELEASE
3390 {
3391 tolua_Error tolua_err;
3392 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3393 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3394 }
3395 #endif
3396 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3397 #ifndef TOLUA_RELEASE
3398 if (tolua_index<0 || tolua_index>=8)
3399 tolua_error(tolua_S,"array indexing out of range.",NULL);
3400 #endif
3401 self->Y[tolua_index] = ((int) tolua_tonumber(tolua_S,3,0));
3402 return 0;
3403 }
3404 #endif //#ifndef TOLUA_DISABLE
3405
3406 /* method: SetRadius of class CPieMenu */
3407 #ifndef TOLUA_DISABLE_tolua_stratagus_CPieMenu_SetRadius00
3408 static int tolua_stratagus_CPieMenu_SetRadius00(lua_State* tolua_S)
3409 {
3410 #ifndef TOLUA_RELEASE
3411 tolua_Error tolua_err;
3412 if (
3413 !tolua_isusertype(tolua_S,1,"CPieMenu",0,&tolua_err) ||
3414 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3415 !tolua_isnoobj(tolua_S,3,&tolua_err)
3416 )
3417 goto tolua_lerror;
3418 else
3419 #endif
3420 {
3421 CPieMenu* self = (CPieMenu*) tolua_tousertype(tolua_S,1,0);
3422 int radius = ((int) tolua_tonumber(tolua_S,2,0));
3423 #ifndef TOLUA_RELEASE
3424 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRadius'", NULL);
3425 #endif
3426 {
3427 self->SetRadius(radius);
3428 }
3429 }
3430 return 0;
3431 #ifndef TOLUA_RELEASE
3432 tolua_lerror:
3433 tolua_error(tolua_S,"#ferror in function 'SetRadius'.",&tolua_err);
3434 return 0;
3435 #endif
3436 }
3437 #endif //#ifndef TOLUA_DISABLE
3438
3439 /* get function: G of class CResourceInfo */
3440 #ifndef TOLUA_DISABLE_tolua_get_CResourceInfo_G_ptr
3441 static int tolua_get_CResourceInfo_G_ptr(lua_State* tolua_S)
3442 {
3443 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3444 #ifndef TOLUA_RELEASE
3445 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
3446 #endif
3447 tolua_pushusertype(tolua_S,(void*)self->G,"CGraphic");
3448 return 1;
3449 }
3450 #endif //#ifndef TOLUA_DISABLE
3451
3452 /* set function: G of class CResourceInfo */
3453 #ifndef TOLUA_DISABLE_tolua_set_CResourceInfo_G_ptr
3454 static int tolua_set_CResourceInfo_G_ptr(lua_State* tolua_S)
3455 {
3456 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3457 #ifndef TOLUA_RELEASE
3458 tolua_Error tolua_err;
3459 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
3460 if (!tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err))
3461 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3462 #endif
3463 self->G = ((CGraphic*) tolua_tousertype(tolua_S,2,0))
3464 ;
3465 return 0;
3466 }
3467 #endif //#ifndef TOLUA_DISABLE
3468
3469 /* get function: IconFrame of class CResourceInfo */
3470 #ifndef TOLUA_DISABLE_tolua_get_CResourceInfo_IconFrame
3471 static int tolua_get_CResourceInfo_IconFrame(lua_State* tolua_S)
3472 {
3473 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3474 #ifndef TOLUA_RELEASE
3475 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IconFrame'",NULL);
3476 #endif
3477 tolua_pushnumber(tolua_S,(lua_Number)self->IconFrame);
3478 return 1;
3479 }
3480 #endif //#ifndef TOLUA_DISABLE
3481
3482 /* set function: IconFrame of class CResourceInfo */
3483 #ifndef TOLUA_DISABLE_tolua_set_CResourceInfo_IconFrame
3484 static int tolua_set_CResourceInfo_IconFrame(lua_State* tolua_S)
3485 {
3486 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3487 #ifndef TOLUA_RELEASE
3488 tolua_Error tolua_err;
3489 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IconFrame'",NULL);
3490 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3491 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3492 #endif
3493 self->IconFrame = ((int) tolua_tonumber(tolua_S,2,0))
3494 ;
3495 return 0;
3496 }
3497 #endif //#ifndef TOLUA_DISABLE
3498
3499 /* get function: IconX of class CResourceInfo */
3500 #ifndef TOLUA_DISABLE_tolua_get_CResourceInfo_IconX
3501 static int tolua_get_CResourceInfo_IconX(lua_State* tolua_S)
3502 {
3503 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3504 #ifndef TOLUA_RELEASE
3505 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IconX'",NULL);
3506 #endif
3507 tolua_pushnumber(tolua_S,(lua_Number)self->IconX);
3508 return 1;
3509 }
3510 #endif //#ifndef TOLUA_DISABLE
3511
3512 /* set function: IconX of class CResourceInfo */
3513 #ifndef TOLUA_DISABLE_tolua_set_CResourceInfo_IconX
3514 static int tolua_set_CResourceInfo_IconX(lua_State* tolua_S)
3515 {
3516 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3517 #ifndef TOLUA_RELEASE
3518 tolua_Error tolua_err;
3519 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IconX'",NULL);
3520 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3521 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3522 #endif
3523 self->IconX = ((int) tolua_tonumber(tolua_S,2,0))
3524 ;
3525 return 0;
3526 }
3527 #endif //#ifndef TOLUA_DISABLE
3528
3529 /* get function: IconY of class CResourceInfo */
3530 #ifndef TOLUA_DISABLE_tolua_get_CResourceInfo_IconY
3531 static int tolua_get_CResourceInfo_IconY(lua_State* tolua_S)
3532 {
3533 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3534 #ifndef TOLUA_RELEASE
3535 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IconY'",NULL);
3536 #endif
3537 tolua_pushnumber(tolua_S,(lua_Number)self->IconY);
3538 return 1;
3539 }
3540 #endif //#ifndef TOLUA_DISABLE
3541
3542 /* set function: IconY of class CResourceInfo */
3543 #ifndef TOLUA_DISABLE_tolua_set_CResourceInfo_IconY
3544 static int tolua_set_CResourceInfo_IconY(lua_State* tolua_S)
3545 {
3546 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3547 #ifndef TOLUA_RELEASE
3548 tolua_Error tolua_err;
3549 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IconY'",NULL);
3550 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3551 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3552 #endif
3553 self->IconY = ((int) tolua_tonumber(tolua_S,2,0))
3554 ;
3555 return 0;
3556 }
3557 #endif //#ifndef TOLUA_DISABLE
3558
3559 /* get function: TextX of class CResourceInfo */
3560 #ifndef TOLUA_DISABLE_tolua_get_CResourceInfo_TextX
3561 static int tolua_get_CResourceInfo_TextX(lua_State* tolua_S)
3562 {
3563 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3564 #ifndef TOLUA_RELEASE
3565 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TextX'",NULL);
3566 #endif
3567 tolua_pushnumber(tolua_S,(lua_Number)self->TextX);
3568 return 1;
3569 }
3570 #endif //#ifndef TOLUA_DISABLE
3571
3572 /* set function: TextX of class CResourceInfo */
3573 #ifndef TOLUA_DISABLE_tolua_set_CResourceInfo_TextX
3574 static int tolua_set_CResourceInfo_TextX(lua_State* tolua_S)
3575 {
3576 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3577 #ifndef TOLUA_RELEASE
3578 tolua_Error tolua_err;
3579 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TextX'",NULL);
3580 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3581 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3582 #endif
3583 self->TextX = ((int) tolua_tonumber(tolua_S,2,0))
3584 ;
3585 return 0;
3586 }
3587 #endif //#ifndef TOLUA_DISABLE
3588
3589 /* get function: TextY of class CResourceInfo */
3590 #ifndef TOLUA_DISABLE_tolua_get_CResourceInfo_TextY
3591 static int tolua_get_CResourceInfo_TextY(lua_State* tolua_S)
3592 {
3593 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3594 #ifndef TOLUA_RELEASE
3595 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TextY'",NULL);
3596 #endif
3597 tolua_pushnumber(tolua_S,(lua_Number)self->TextY);
3598 return 1;
3599 }
3600 #endif //#ifndef TOLUA_DISABLE
3601
3602 /* set function: TextY of class CResourceInfo */
3603 #ifndef TOLUA_DISABLE_tolua_set_CResourceInfo_TextY
3604 static int tolua_set_CResourceInfo_TextY(lua_State* tolua_S)
3605 {
3606 CResourceInfo* self = (CResourceInfo*) tolua_tousertype(tolua_S,1,0);
3607 #ifndef TOLUA_RELEASE
3608 tolua_Error tolua_err;
3609 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TextY'",NULL);
3610 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3611 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3612 #endif
3613 self->TextY = ((int) tolua_tonumber(tolua_S,2,0))
3614 ;
3615 return 0;
3616 }
3617 #endif //#ifndef TOLUA_DISABLE
3618
3619 /* get function: X of class CInfoPanel */
3620 #ifndef TOLUA_DISABLE_tolua_get_CInfoPanel_X
3621 static int tolua_get_CInfoPanel_X(lua_State* tolua_S)
3622 {
3623 CInfoPanel* self = (CInfoPanel*) tolua_tousertype(tolua_S,1,0);
3624 #ifndef TOLUA_RELEASE
3625 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
3626 #endif
3627 tolua_pushnumber(tolua_S,(lua_Number)self->X);
3628 return 1;
3629 }
3630 #endif //#ifndef TOLUA_DISABLE
3631
3632 /* set function: X of class CInfoPanel */
3633 #ifndef TOLUA_DISABLE_tolua_set_CInfoPanel_X
3634 static int tolua_set_CInfoPanel_X(lua_State* tolua_S)
3635 {
3636 CInfoPanel* self = (CInfoPanel*) tolua_tousertype(tolua_S,1,0);
3637 #ifndef TOLUA_RELEASE
3638 tolua_Error tolua_err;
3639 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
3640 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3641 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3642 #endif
3643 self->X = ((int) tolua_tonumber(tolua_S,2,0))
3644 ;
3645 return 0;
3646 }
3647 #endif //#ifndef TOLUA_DISABLE
3648
3649 /* get function: Y of class CInfoPanel */
3650 #ifndef TOLUA_DISABLE_tolua_get_CInfoPanel_Y
3651 static int tolua_get_CInfoPanel_Y(lua_State* tolua_S)
3652 {
3653 CInfoPanel* self = (CInfoPanel*) tolua_tousertype(tolua_S,1,0);
3654 #ifndef TOLUA_RELEASE
3655 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
3656 #endif
3657 tolua_pushnumber(tolua_S,(lua_Number)self->Y);
3658 return 1;
3659 }
3660 #endif //#ifndef TOLUA_DISABLE
3661
3662 /* set function: Y of class CInfoPanel */
3663 #ifndef TOLUA_DISABLE_tolua_set_CInfoPanel_Y
3664 static int tolua_set_CInfoPanel_Y(lua_State* tolua_S)
3665 {
3666 CInfoPanel* self = (CInfoPanel*) tolua_tousertype(tolua_S,1,0);
3667 #ifndef TOLUA_RELEASE
3668 tolua_Error tolua_err;
3669 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
3670 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3671 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3672 #endif
3673 self->Y = ((int) tolua_tonumber(tolua_S,2,0))
3674 ;
3675 return 0;
3676 }
3677 #endif //#ifndef TOLUA_DISABLE
3678
3679 /* method: Set of class CStatusLine */
3680 #ifndef TOLUA_DISABLE_tolua_stratagus_CStatusLine_Set00
3681 static int tolua_stratagus_CStatusLine_Set00(lua_State* tolua_S)
3682 {
3683 #ifndef TOLUA_RELEASE
3684 tolua_Error tolua_err;
3685 if (
3686 !tolua_isusertype(tolua_S,1,"CStatusLine",0,&tolua_err) ||
3687 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
3688 !tolua_isnoobj(tolua_S,3,&tolua_err)
3689 )
3690 goto tolua_lerror;
3691 else
3692 #endif
3693 {
3694 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3695 const std::string status = ((const std::string) tolua_tocppstring(tolua_S,2,0));
3696 #ifndef TOLUA_RELEASE
3697 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'", NULL);
3698 #endif
3699 {
3700 self->Set(status);
3701 }
3702 }
3703 return 0;
3704 #ifndef TOLUA_RELEASE
3705 tolua_lerror:
3706 tolua_error(tolua_S,"#ferror in function 'Set'.",&tolua_err);
3707 return 0;
3708 #endif
3709 }
3710 #endif //#ifndef TOLUA_DISABLE
3711
3712 /* method: Get of class CStatusLine */
3713 #ifndef TOLUA_DISABLE_tolua_stratagus_CStatusLine_Get00
3714 static int tolua_stratagus_CStatusLine_Get00(lua_State* tolua_S)
3715 {
3716 #ifndef TOLUA_RELEASE
3717 tolua_Error tolua_err;
3718 if (
3719 !tolua_isusertype(tolua_S,1,"CStatusLine",0,&tolua_err) ||
3720 !tolua_isnoobj(tolua_S,2,&tolua_err)
3721 )
3722 goto tolua_lerror;
3723 else
3724 #endif
3725 {
3726 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3727 #ifndef TOLUA_RELEASE
3728 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Get'", NULL);
3729 #endif
3730 {
3731 const std::string tolua_ret = (const std::string) self->Get();
3732 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
3733 }
3734 }
3735 return 1;
3736 #ifndef TOLUA_RELEASE
3737 tolua_lerror:
3738 tolua_error(tolua_S,"#ferror in function 'Get'.",&tolua_err);
3739 return 0;
3740 #endif
3741 }
3742 #endif //#ifndef TOLUA_DISABLE
3743
3744 /* method: Clear of class CStatusLine */
3745 #ifndef TOLUA_DISABLE_tolua_stratagus_CStatusLine_Clear00
3746 static int tolua_stratagus_CStatusLine_Clear00(lua_State* tolua_S)
3747 {
3748 #ifndef TOLUA_RELEASE
3749 tolua_Error tolua_err;
3750 if (
3751 !tolua_isusertype(tolua_S,1,"CStatusLine",0,&tolua_err) ||
3752 !tolua_isnoobj(tolua_S,2,&tolua_err)
3753 )
3754 goto tolua_lerror;
3755 else
3756 #endif
3757 {
3758 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3759 #ifndef TOLUA_RELEASE
3760 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", NULL);
3761 #endif
3762 {
3763 self->Clear();
3764 }
3765 }
3766 return 0;
3767 #ifndef TOLUA_RELEASE
3768 tolua_lerror:
3769 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
3770 return 0;
3771 #endif
3772 }
3773 #endif //#ifndef TOLUA_DISABLE
3774
3775 /* get function: Width of class CStatusLine */
3776 #ifndef TOLUA_DISABLE_tolua_get_CStatusLine_Width
3777 static int tolua_get_CStatusLine_Width(lua_State* tolua_S)
3778 {
3779 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3780 #ifndef TOLUA_RELEASE
3781 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Width'",NULL);
3782 #endif
3783 tolua_pushnumber(tolua_S,(lua_Number)self->Width);
3784 return 1;
3785 }
3786 #endif //#ifndef TOLUA_DISABLE
3787
3788 /* set function: Width of class CStatusLine */
3789 #ifndef TOLUA_DISABLE_tolua_set_CStatusLine_Width
3790 static int tolua_set_CStatusLine_Width(lua_State* tolua_S)
3791 {
3792 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3793 #ifndef TOLUA_RELEASE
3794 tolua_Error tolua_err;
3795 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Width'",NULL);
3796 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3797 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3798 #endif
3799 self->Width = ((int) tolua_tonumber(tolua_S,2,0))
3800 ;
3801 return 0;
3802 }
3803 #endif //#ifndef TOLUA_DISABLE
3804
3805 /* get function: TextX of class CStatusLine */
3806 #ifndef TOLUA_DISABLE_tolua_get_CStatusLine_TextX
3807 static int tolua_get_CStatusLine_TextX(lua_State* tolua_S)
3808 {
3809 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3810 #ifndef TOLUA_RELEASE
3811 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TextX'",NULL);
3812 #endif
3813 tolua_pushnumber(tolua_S,(lua_Number)self->TextX);
3814 return 1;
3815 }
3816 #endif //#ifndef TOLUA_DISABLE
3817
3818 /* set function: TextX of class CStatusLine */
3819 #ifndef TOLUA_DISABLE_tolua_set_CStatusLine_TextX
3820 static int tolua_set_CStatusLine_TextX(lua_State* tolua_S)
3821 {
3822 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3823 #ifndef TOLUA_RELEASE
3824 tolua_Error tolua_err;
3825 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TextX'",NULL);
3826 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3827 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3828 #endif
3829 self->TextX = ((int) tolua_tonumber(tolua_S,2,0))
3830 ;
3831 return 0;
3832 }
3833 #endif //#ifndef TOLUA_DISABLE
3834
3835 /* get function: TextY of class CStatusLine */
3836 #ifndef TOLUA_DISABLE_tolua_get_CStatusLine_TextY
3837 static int tolua_get_CStatusLine_TextY(lua_State* tolua_S)
3838 {
3839 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3840 #ifndef TOLUA_RELEASE
3841 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TextY'",NULL);
3842 #endif
3843 tolua_pushnumber(tolua_S,(lua_Number)self->TextY);
3844 return 1;
3845 }
3846 #endif //#ifndef TOLUA_DISABLE
3847
3848 /* set function: TextY of class CStatusLine */
3849 #ifndef TOLUA_DISABLE_tolua_set_CStatusLine_TextY
3850 static int tolua_set_CStatusLine_TextY(lua_State* tolua_S)
3851 {
3852 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3853 #ifndef TOLUA_RELEASE
3854 tolua_Error tolua_err;
3855 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TextY'",NULL);
3856 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3857 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3858 #endif
3859 self->TextY = ((int) tolua_tonumber(tolua_S,2,0))
3860 ;
3861 return 0;
3862 }
3863 #endif //#ifndef TOLUA_DISABLE
3864
3865 /* get function: Font of class CStatusLine */
3866 #ifndef TOLUA_DISABLE_tolua_get_CStatusLine_Font_ptr
3867 static int tolua_get_CStatusLine_Font_ptr(lua_State* tolua_S)
3868 {
3869 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3870 #ifndef TOLUA_RELEASE
3871 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Font'",NULL);
3872 #endif
3873 tolua_pushusertype(tolua_S,(void*)self->Font,"CFont");
3874 return 1;
3875 }
3876 #endif //#ifndef TOLUA_DISABLE
3877
3878 /* set function: Font of class CStatusLine */
3879 #ifndef TOLUA_DISABLE_tolua_set_CStatusLine_Font_ptr
3880 static int tolua_set_CStatusLine_Font_ptr(lua_State* tolua_S)
3881 {
3882 CStatusLine* self = (CStatusLine*) tolua_tousertype(tolua_S,1,0);
3883 #ifndef TOLUA_RELEASE
3884 tolua_Error tolua_err;
3885 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Font'",NULL);
3886 if (!tolua_isusertype(tolua_S,2,"CFont",0,&tolua_err))
3887 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3888 #endif
3889 self->Font = ((CFont*) tolua_tousertype(tolua_S,2,0))
3890 ;
3891 return 0;
3892 }
3893 #endif //#ifndef TOLUA_DISABLE
3894
3895 /* get function: X of class CUITimer */
3896 #ifndef TOLUA_DISABLE_tolua_get_CUITimer_X
3897 static int tolua_get_CUITimer_X(lua_State* tolua_S)
3898 {
3899 CUITimer* self = (CUITimer*) tolua_tousertype(tolua_S,1,0);
3900 #ifndef TOLUA_RELEASE
3901 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
3902 #endif
3903 tolua_pushnumber(tolua_S,(lua_Number)self->X);
3904 return 1;
3905 }
3906 #endif //#ifndef TOLUA_DISABLE
3907
3908 /* set function: X of class CUITimer */
3909 #ifndef TOLUA_DISABLE_tolua_set_CUITimer_X
3910 static int tolua_set_CUITimer_X(lua_State* tolua_S)
3911 {
3912 CUITimer* self = (CUITimer*) tolua_tousertype(tolua_S,1,0);
3913 #ifndef TOLUA_RELEASE
3914 tolua_Error tolua_err;
3915 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
3916 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3917 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3918 #endif
3919 self->X = ((int) tolua_tonumber(tolua_S,2,0))
3920 ;
3921 return 0;
3922 }
3923 #endif //#ifndef TOLUA_DISABLE
3924
3925 /* get function: Y of class CUITimer */
3926 #ifndef TOLUA_DISABLE_tolua_get_CUITimer_Y
3927 static int tolua_get_CUITimer_Y(lua_State* tolua_S)
3928 {
3929 CUITimer* self = (CUITimer*) tolua_tousertype(tolua_S,1,0);
3930 #ifndef TOLUA_RELEASE
3931 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
3932 #endif
3933 tolua_pushnumber(tolua_S,(lua_Number)self->Y);
3934 return 1;
3935 }
3936 #endif //#ifndef TOLUA_DISABLE
3937
3938 /* set function: Y of class CUITimer */
3939 #ifndef TOLUA_DISABLE_tolua_set_CUITimer_Y
3940 static int tolua_set_CUITimer_Y(lua_State* tolua_S)
3941 {
3942 CUITimer* self = (CUITimer*) tolua_tousertype(tolua_S,1,0);
3943 #ifndef TOLUA_RELEASE
3944 tolua_Error tolua_err;
3945 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
3946 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3947 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3948 #endif
3949 self->Y = ((int) tolua_tonumber(tolua_S,2,0))
3950 ;
3951 return 0;
3952 }
3953 #endif //#ifndef TOLUA_DISABLE
3954
3955 /* get function: Font of class CUITimer */
3956 #ifndef TOLUA_DISABLE_tolua_get_CUITimer_Font_ptr
3957 static int tolua_get_CUITimer_Font_ptr(lua_State* tolua_S)
3958 {
3959 CUITimer* self = (CUITimer*) tolua_tousertype(tolua_S,1,0);
3960 #ifndef TOLUA_RELEASE
3961 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Font'",NULL);
3962 #endif
3963 tolua_pushusertype(tolua_S,(void*)self->Font,"CFont");
3964 return 1;
3965 }
3966 #endif //#ifndef TOLUA_DISABLE
3967
3968 /* set function: Font of class CUITimer */
3969 #ifndef TOLUA_DISABLE_tolua_set_CUITimer_Font_ptr
3970 static int tolua_set_CUITimer_Font_ptr(lua_State* tolua_S)
3971 {
3972 CUITimer* self = (CUITimer*) tolua_tousertype(tolua_S,1,0);
3973 #ifndef TOLUA_RELEASE
3974 tolua_Error tolua_err;
3975 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Font'",NULL);
3976 if (!tolua_isusertype(tolua_S,2,"CFont",0,&tolua_err))
3977 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3978 #endif
3979 self->Font = ((CFont*) tolua_tousertype(tolua_S,2,0))
3980 ;
3981 return 0;
3982 }
3983 #endif //#ifndef TOLUA_DISABLE
3984
3985 /* get function: NormalFontColor of class CUserInterface */
3986 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_NormalFontColor
3987 static int tolua_get_CUserInterface_NormalFontColor(lua_State* tolua_S)
3988 {
3989 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
3990 #ifndef TOLUA_RELEASE
3991 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NormalFontColor'",NULL);
3992 #endif
3993 tolua_pushcppstring(tolua_S,(const char*)self->NormalFontColor);
3994 return 1;
3995 }
3996 #endif //#ifndef TOLUA_DISABLE
3997
3998 /* set function: NormalFontColor of class CUserInterface */
3999 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_NormalFontColor
4000 static int tolua_set_CUserInterface_NormalFontColor(lua_State* tolua_S)
4001 {
4002 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4003 #ifndef TOLUA_RELEASE
4004 tolua_Error tolua_err;
4005 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NormalFontColor'",NULL);
4006 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
4007 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4008 #endif
4009 self->NormalFontColor = ((string) tolua_tocppstring(tolua_S,2,0))
4010 ;
4011 return 0;
4012 }
4013 #endif //#ifndef TOLUA_DISABLE
4014
4015 /* get function: ReverseFontColor of class CUserInterface */
4016 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_ReverseFontColor
4017 static int tolua_get_CUserInterface_ReverseFontColor(lua_State* tolua_S)
4018 {
4019 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4020 #ifndef TOLUA_RELEASE
4021 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ReverseFontColor'",NULL);
4022 #endif
4023 tolua_pushcppstring(tolua_S,(const char*)self->ReverseFontColor);
4024 return 1;
4025 }
4026 #endif //#ifndef TOLUA_DISABLE
4027
4028 /* set function: ReverseFontColor of class CUserInterface */
4029 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_ReverseFontColor
4030 static int tolua_set_CUserInterface_ReverseFontColor(lua_State* tolua_S)
4031 {
4032 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4033 #ifndef TOLUA_RELEASE
4034 tolua_Error tolua_err;
4035 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ReverseFontColor'",NULL);
4036 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
4037 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4038 #endif
4039 self->ReverseFontColor = ((string) tolua_tocppstring(tolua_S,2,0))
4040 ;
4041 return 0;
4042 }
4043 #endif //#ifndef TOLUA_DISABLE
4044
4045 /* get function: Fillers of class CUserInterface */
4046 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_Fillers
4047 static int tolua_get_CUserInterface_Fillers(lua_State* tolua_S)
4048 {
4049 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4050 #ifndef TOLUA_RELEASE
4051 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Fillers'",NULL);
4052 #endif
4053 tolua_pushusertype(tolua_S,(void*)&self->Fillers,"vector<CFiller>");
4054 return 1;
4055 }
4056 #endif //#ifndef TOLUA_DISABLE
4057
4058 /* set function: Fillers of class CUserInterface */
4059 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_Fillers
4060 static int tolua_set_CUserInterface_Fillers(lua_State* tolua_S)
4061 {
4062 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4063 #ifndef TOLUA_RELEASE
4064 tolua_Error tolua_err;
4065 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Fillers'",NULL);
4066 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<CFiller>",0,&tolua_err)))
4067 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4068 #endif
4069 self->Fillers = *((vector<CFiller>*) tolua_tousertype(tolua_S,2,0))
4070 ;
4071 return 0;
4072 }
4073 #endif //#ifndef TOLUA_DISABLE
4074
4075 /* get function: Resources of class CUserInterface */
4076 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CUserInterface_Resources
4077 static int tolua_get_stratagus_CUserInterface_Resources(lua_State* tolua_S)
4078 {
4079 int tolua_index;
4080 CUserInterface* self;
4081 lua_pushstring(tolua_S,".self");
4082 lua_rawget(tolua_S,1);
4083 self = (CUserInterface*) lua_touserdata(tolua_S,-1);
4084 #ifndef TOLUA_RELEASE
4085 {
4086 tolua_Error tolua_err;
4087 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4088 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
4089 }
4090 #endif
4091 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
4092 #ifndef TOLUA_RELEASE
4093 if (tolua_index<0 || tolua_index>=MaxCosts)
4094 tolua_error(tolua_S,"array indexing out of range.",NULL);
4095 #endif
4096 tolua_pushusertype(tolua_S,(void*)&self->Resources[tolua_index],"CResourceInfo");
4097 return 1;
4098 }
4099 #endif //#ifndef TOLUA_DISABLE
4100
4101 /* set function: Resources of class CUserInterface */
4102 #ifndef TOLUA_DISABLE_tolua_set_stratagus_CUserInterface_Resources
4103 static int tolua_set_stratagus_CUserInterface_Resources(lua_State* tolua_S)
4104 {
4105 int tolua_index;
4106 CUserInterface* self;
4107 lua_pushstring(tolua_S,".self");
4108 lua_rawget(tolua_S,1);
4109 self = (CUserInterface*) lua_touserdata(tolua_S,-1);
4110 #ifndef TOLUA_RELEASE
4111 {
4112 tolua_Error tolua_err;
4113 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4114 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
4115 }
4116 #endif
4117 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
4118 #ifndef TOLUA_RELEASE
4119 if (tolua_index<0 || tolua_index>=MaxCosts)
4120 tolua_error(tolua_S,"array indexing out of range.",NULL);
4121 #endif
4122 self->Resources[tolua_index] = *((CResourceInfo*) tolua_tousertype(tolua_S,3,0));
4123 return 0;
4124 }
4125 #endif //#ifndef TOLUA_DISABLE
4126
4127 /* get function: InfoPanel of class CUserInterface */
4128 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_InfoPanel
4129 static int tolua_get_CUserInterface_InfoPanel(lua_State* tolua_S)
4130 {
4131 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4132 #ifndef TOLUA_RELEASE
4133 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InfoPanel'",NULL);
4134 #endif
4135 tolua_pushusertype(tolua_S,(void*)&self->InfoPanel,"CInfoPanel");
4136 return 1;
4137 }
4138 #endif //#ifndef TOLUA_DISABLE
4139
4140 /* set function: InfoPanel of class CUserInterface */
4141 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_InfoPanel
4142 static int tolua_set_CUserInterface_InfoPanel(lua_State* tolua_S)
4143 {
4144 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4145 #ifndef TOLUA_RELEASE
4146 tolua_Error tolua_err;
4147 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InfoPanel'",NULL);
4148 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CInfoPanel",0,&tolua_err)))
4149 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4150 #endif
4151 self->InfoPanel = *((CInfoPanel*) tolua_tousertype(tolua_S,2,0))
4152 ;
4153 return 0;
4154 }
4155 #endif //#ifndef TOLUA_DISABLE
4156
4157 /* get function: SingleSelectedButton of class CUserInterface */
4158 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_SingleSelectedButton_ptr
4159 static int tolua_get_CUserInterface_SingleSelectedButton_ptr(lua_State* tolua_S)
4160 {
4161 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4162 #ifndef TOLUA_RELEASE
4163 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SingleSelectedButton'",NULL);
4164 #endif
4165 tolua_pushusertype(tolua_S,(void*)self->SingleSelectedButton,"CUIButton");
4166 return 1;
4167 }
4168 #endif //#ifndef TOLUA_DISABLE
4169
4170 /* set function: SingleSelectedButton of class CUserInterface */
4171 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_SingleSelectedButton_ptr
4172 static int tolua_set_CUserInterface_SingleSelectedButton_ptr(lua_State* tolua_S)
4173 {
4174 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4175 #ifndef TOLUA_RELEASE
4176 tolua_Error tolua_err;
4177 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SingleSelectedButton'",NULL);
4178 if (!tolua_isusertype(tolua_S,2,"CUIButton",0,&tolua_err))
4179 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4180 #endif
4181 self->SingleSelectedButton = ((CUIButton*) tolua_tousertype(tolua_S,2,0))
4182 ;
4183 return 0;
4184 }
4185 #endif //#ifndef TOLUA_DISABLE
4186
4187 /* get function: SelectedButtons of class CUserInterface */
4188 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_SelectedButtons
4189 static int tolua_get_CUserInterface_SelectedButtons(lua_State* tolua_S)
4190 {
4191 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4192 #ifndef TOLUA_RELEASE
4193 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SelectedButtons'",NULL);
4194 #endif
4195 tolua_pushusertype(tolua_S,(void*)&self->SelectedButtons,"vector<CUIButton>");
4196 return 1;
4197 }
4198 #endif //#ifndef TOLUA_DISABLE
4199
4200 /* set function: SelectedButtons of class CUserInterface */
4201 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_SelectedButtons
4202 static int tolua_set_CUserInterface_SelectedButtons(lua_State* tolua_S)
4203 {
4204 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4205 #ifndef TOLUA_RELEASE
4206 tolua_Error tolua_err;
4207 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SelectedButtons'",NULL);
4208 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<CUIButton>",0,&tolua_err)))
4209 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4210 #endif
4211 self->SelectedButtons = *((vector<CUIButton>*) tolua_tousertype(tolua_S,2,0))
4212 ;
4213 return 0;
4214 }
4215 #endif //#ifndef TOLUA_DISABLE
4216
4217 /* get function: MaxSelectedFont of class CUserInterface */
4218 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_MaxSelectedFont_ptr
4219 static int tolua_get_CUserInterface_MaxSelectedFont_ptr(lua_State* tolua_S)
4220 {
4221 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4222 #ifndef TOLUA_RELEASE
4223 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSelectedFont'",NULL);
4224 #endif
4225 tolua_pushusertype(tolua_S,(void*)self->MaxSelectedFont,"CFont");
4226 return 1;
4227 }
4228 #endif //#ifndef TOLUA_DISABLE
4229
4230 /* set function: MaxSelectedFont of class CUserInterface */
4231 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_MaxSelectedFont_ptr
4232 static int tolua_set_CUserInterface_MaxSelectedFont_ptr(lua_State* tolua_S)
4233 {
4234 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4235 #ifndef TOLUA_RELEASE
4236 tolua_Error tolua_err;
4237 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSelectedFont'",NULL);
4238 if (!tolua_isusertype(tolua_S,2,"CFont",0,&tolua_err))
4239 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4240 #endif
4241 self->MaxSelectedFont = ((CFont*) tolua_tousertype(tolua_S,2,0))
4242 ;
4243 return 0;
4244 }
4245 #endif //#ifndef TOLUA_DISABLE
4246
4247 /* get function: MaxSelectedTextX of class CUserInterface */
4248 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_MaxSelectedTextX
4249 static int tolua_get_CUserInterface_MaxSelectedTextX(lua_State* tolua_S)
4250 {
4251 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4252 #ifndef TOLUA_RELEASE
4253 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSelectedTextX'",NULL);
4254 #endif
4255 tolua_pushnumber(tolua_S,(lua_Number)self->MaxSelectedTextX);
4256 return 1;
4257 }
4258 #endif //#ifndef TOLUA_DISABLE
4259
4260 /* set function: MaxSelectedTextX of class CUserInterface */
4261 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_MaxSelectedTextX
4262 static int tolua_set_CUserInterface_MaxSelectedTextX(lua_State* tolua_S)
4263 {
4264 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4265 #ifndef TOLUA_RELEASE
4266 tolua_Error tolua_err;
4267 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSelectedTextX'",NULL);
4268 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4269 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4270 #endif
4271 self->MaxSelectedTextX = ((int) tolua_tonumber(tolua_S,2,0))
4272 ;
4273 return 0;
4274 }
4275 #endif //#ifndef TOLUA_DISABLE
4276
4277 /* get function: MaxSelectedTextY of class CUserInterface */
4278 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_MaxSelectedTextY
4279 static int tolua_get_CUserInterface_MaxSelectedTextY(lua_State* tolua_S)
4280 {
4281 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4282 #ifndef TOLUA_RELEASE
4283 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSelectedTextY'",NULL);
4284 #endif
4285 tolua_pushnumber(tolua_S,(lua_Number)self->MaxSelectedTextY);
4286 return 1;
4287 }
4288 #endif //#ifndef TOLUA_DISABLE
4289
4290 /* set function: MaxSelectedTextY of class CUserInterface */
4291 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_MaxSelectedTextY
4292 static int tolua_set_CUserInterface_MaxSelectedTextY(lua_State* tolua_S)
4293 {
4294 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4295 #ifndef TOLUA_RELEASE
4296 tolua_Error tolua_err;
4297 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSelectedTextY'",NULL);
4298 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4299 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4300 #endif
4301 self->MaxSelectedTextY = ((int) tolua_tonumber(tolua_S,2,0))
4302 ;
4303 return 0;
4304 }
4305 #endif //#ifndef TOLUA_DISABLE
4306
4307 /* get function: SingleTrainingButton of class CUserInterface */
4308 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_SingleTrainingButton_ptr
4309 static int tolua_get_CUserInterface_SingleTrainingButton_ptr(lua_State* tolua_S)
4310 {
4311 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4312 #ifndef TOLUA_RELEASE
4313 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SingleTrainingButton'",NULL);
4314 #endif
4315 tolua_pushusertype(tolua_S,(void*)self->SingleTrainingButton,"CUIButton");
4316 return 1;
4317 }
4318 #endif //#ifndef TOLUA_DISABLE
4319
4320 /* set function: SingleTrainingButton of class CUserInterface */
4321 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_SingleTrainingButton_ptr
4322 static int tolua_set_CUserInterface_SingleTrainingButton_ptr(lua_State* tolua_S)
4323 {
4324 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4325 #ifndef TOLUA_RELEASE
4326 tolua_Error tolua_err;
4327 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SingleTrainingButton'",NULL);
4328 if (!tolua_isusertype(tolua_S,2,"CUIButton",0,&tolua_err))
4329 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4330 #endif
4331 self->SingleTrainingButton = ((CUIButton*) tolua_tousertype(tolua_S,2,0))
4332 ;
4333 return 0;
4334 }
4335 #endif //#ifndef TOLUA_DISABLE
4336
4337 /* get function: TrainingButtons of class CUserInterface */
4338 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_TrainingButtons
4339 static int tolua_get_CUserInterface_TrainingButtons(lua_State* tolua_S)
4340 {
4341 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4342 #ifndef TOLUA_RELEASE
4343 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TrainingButtons'",NULL);
4344 #endif
4345 tolua_pushusertype(tolua_S,(void*)&self->TrainingButtons,"vector<CUIButton>");
4346 return 1;
4347 }
4348 #endif //#ifndef TOLUA_DISABLE
4349
4350 /* set function: TrainingButtons of class CUserInterface */
4351 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_TrainingButtons
4352 static int tolua_set_CUserInterface_TrainingButtons(lua_State* tolua_S)
4353 {
4354 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4355 #ifndef TOLUA_RELEASE
4356 tolua_Error tolua_err;
4357 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TrainingButtons'",NULL);
4358 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<CUIButton>",0,&tolua_err)))
4359 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4360 #endif
4361 self->TrainingButtons = *((vector<CUIButton>*) tolua_tousertype(tolua_S,2,0))
4362 ;
4363 return 0;
4364 }
4365 #endif //#ifndef TOLUA_DISABLE
4366
4367 /* get function: TransportingButtons of class CUserInterface */
4368 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_TransportingButtons
4369 static int tolua_get_CUserInterface_TransportingButtons(lua_State* tolua_S)
4370 {
4371 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4372 #ifndef TOLUA_RELEASE
4373 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TransportingButtons'",NULL);
4374 #endif
4375 tolua_pushusertype(tolua_S,(void*)&self->TransportingButtons,"vector<CUIButton>");
4376 return 1;
4377 }
4378 #endif //#ifndef TOLUA_DISABLE
4379
4380 /* set function: TransportingButtons of class CUserInterface */
4381 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_TransportingButtons
4382 static int tolua_set_CUserInterface_TransportingButtons(lua_State* tolua_S)
4383 {
4384 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4385 #ifndef TOLUA_RELEASE
4386 tolua_Error tolua_err;
4387 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TransportingButtons'",NULL);
4388 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<CUIButton>",0,&tolua_err)))
4389 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4390 #endif
4391 self->TransportingButtons = *((vector<CUIButton>*) tolua_tousertype(tolua_S,2,0))
4392 ;
4393 return 0;
4394 }
4395 #endif //#ifndef TOLUA_DISABLE
4396
4397 /* get function: CompletedBarColorRGB of class CUserInterface */
4398 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_CompletedBarColorRGB
4399 static int tolua_get_CUserInterface_CompletedBarColorRGB(lua_State* tolua_S)
4400 {
4401 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4402 #ifndef TOLUA_RELEASE
4403 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CompletedBarColorRGB'",NULL);
4404 #endif
4405 tolua_pushusertype(tolua_S,(void*)&self->CompletedBarColorRGB,"CColor");
4406 return 1;
4407 }
4408 #endif //#ifndef TOLUA_DISABLE
4409
4410 /* set function: CompletedBarColorRGB of class CUserInterface */
4411 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_CompletedBarColorRGB
4412 static int tolua_set_CUserInterface_CompletedBarColorRGB(lua_State* tolua_S)
4413 {
4414 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4415 #ifndef TOLUA_RELEASE
4416 tolua_Error tolua_err;
4417 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CompletedBarColorRGB'",NULL);
4418 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CColor",0,&tolua_err)))
4419 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4420 #endif
4421 self->CompletedBarColorRGB = *((CColor*) tolua_tousertype(tolua_S,2,0))
4422 ;
4423 return 0;
4424 }
4425 #endif //#ifndef TOLUA_DISABLE
4426
4427 /* get function: CompletedBarShadow of class CUserInterface */
4428 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_CompletedBarShadow
4429 static int tolua_get_CUserInterface_CompletedBarShadow(lua_State* tolua_S)
4430 {
4431 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4432 #ifndef TOLUA_RELEASE
4433 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CompletedBarShadow'",NULL);
4434 #endif
4435 tolua_pushboolean(tolua_S,(bool)self->CompletedBarShadow);
4436 return 1;
4437 }
4438 #endif //#ifndef TOLUA_DISABLE
4439
4440 /* set function: CompletedBarShadow of class CUserInterface */
4441 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_CompletedBarShadow
4442 static int tolua_set_CUserInterface_CompletedBarShadow(lua_State* tolua_S)
4443 {
4444 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4445 #ifndef TOLUA_RELEASE
4446 tolua_Error tolua_err;
4447 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CompletedBarShadow'",NULL);
4448 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
4449 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4450 #endif
4451 self->CompletedBarShadow = ((bool) tolua_toboolean(tolua_S,2,0))
4452 ;
4453 return 0;
4454 }
4455 #endif //#ifndef TOLUA_DISABLE
4456
4457 /* get function: ButtonPanel of class CUserInterface */
4458 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_ButtonPanel
4459 static int tolua_get_CUserInterface_ButtonPanel(lua_State* tolua_S)
4460 {
4461 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4462 #ifndef TOLUA_RELEASE
4463 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ButtonPanel'",NULL);
4464 #endif
4465 tolua_pushusertype(tolua_S,(void*)&self->ButtonPanel,"CButtonPanel");
4466 return 1;
4467 }
4468 #endif //#ifndef TOLUA_DISABLE
4469
4470 /* set function: ButtonPanel of class CUserInterface */
4471 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_ButtonPanel
4472 static int tolua_set_CUserInterface_ButtonPanel(lua_State* tolua_S)
4473 {
4474 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4475 #ifndef TOLUA_RELEASE
4476 tolua_Error tolua_err;
4477 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ButtonPanel'",NULL);
4478 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CButtonPanel",0,&tolua_err)))
4479 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4480 #endif
4481 self->ButtonPanel = *((CButtonPanel*) tolua_tousertype(tolua_S,2,0))
4482 ;
4483 return 0;
4484 }
4485 #endif //#ifndef TOLUA_DISABLE
4486
4487 /* get function: PieMenu of class CUserInterface */
4488 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_PieMenu
4489 static int tolua_get_CUserInterface_PieMenu(lua_State* tolua_S)
4490 {
4491 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4492 #ifndef TOLUA_RELEASE
4493 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PieMenu'",NULL);
4494 #endif
4495 tolua_pushusertype(tolua_S,(void*)&self->PieMenu,"CPieMenu");
4496 return 1;
4497 }
4498 #endif //#ifndef TOLUA_DISABLE
4499
4500 /* set function: PieMenu of class CUserInterface */
4501 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_PieMenu
4502 static int tolua_set_CUserInterface_PieMenu(lua_State* tolua_S)
4503 {
4504 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4505 #ifndef TOLUA_RELEASE
4506 tolua_Error tolua_err;
4507 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PieMenu'",NULL);
4508 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CPieMenu",0,&tolua_err)))
4509 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4510 #endif
4511 self->PieMenu = *((CPieMenu*) tolua_tousertype(tolua_S,2,0))
4512 ;
4513 return 0;
4514 }
4515 #endif //#ifndef TOLUA_DISABLE
4516
4517 /* get function: MouseViewport of class CUserInterface */
4518 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_MouseViewport_ptr
4519 static int tolua_get_CUserInterface_MouseViewport_ptr(lua_State* tolua_S)
4520 {
4521 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4522 #ifndef TOLUA_RELEASE
4523 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MouseViewport'",NULL);
4524 #endif
4525 tolua_pushusertype(tolua_S,(void*)self->MouseViewport,"CViewport");
4526 return 1;
4527 }
4528 #endif //#ifndef TOLUA_DISABLE
4529
4530 /* set function: MouseViewport of class CUserInterface */
4531 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_MouseViewport_ptr
4532 static int tolua_set_CUserInterface_MouseViewport_ptr(lua_State* tolua_S)
4533 {
4534 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4535 #ifndef TOLUA_RELEASE
4536 tolua_Error tolua_err;
4537 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MouseViewport'",NULL);
4538 if (!tolua_isusertype(tolua_S,2,"CViewport",0,&tolua_err))
4539 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4540 #endif
4541 self->MouseViewport = ((CViewport*) tolua_tousertype(tolua_S,2,0))
4542 ;
4543 return 0;
4544 }
4545 #endif //#ifndef TOLUA_DISABLE
4546
4547 /* get function: MapArea of class CUserInterface */
4548 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_MapArea
4549 static int tolua_get_CUserInterface_MapArea(lua_State* tolua_S)
4550 {
4551 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4552 #ifndef TOLUA_RELEASE
4553 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapArea'",NULL);
4554 #endif
4555 tolua_pushusertype(tolua_S,(void*)&self->MapArea,"CMapArea");
4556 return 1;
4557 }
4558 #endif //#ifndef TOLUA_DISABLE
4559
4560 /* set function: MapArea of class CUserInterface */
4561 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_MapArea
4562 static int tolua_set_CUserInterface_MapArea(lua_State* tolua_S)
4563 {
4564 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4565 #ifndef TOLUA_RELEASE
4566 tolua_Error tolua_err;
4567 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapArea'",NULL);
4568 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CMapArea",0,&tolua_err)))
4569 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4570 #endif
4571 self->MapArea = *((CMapArea*) tolua_tousertype(tolua_S,2,0))
4572 ;
4573 return 0;
4574 }
4575 #endif //#ifndef TOLUA_DISABLE
4576
4577 /* get function: MessageFont of class CUserInterface */
4578 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_MessageFont_ptr
4579 static int tolua_get_CUserInterface_MessageFont_ptr(lua_State* tolua_S)
4580 {
4581 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4582 #ifndef TOLUA_RELEASE
4583 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MessageFont'",NULL);
4584 #endif
4585 tolua_pushusertype(tolua_S,(void*)self->MessageFont,"CFont");
4586 return 1;
4587 }
4588 #endif //#ifndef TOLUA_DISABLE
4589
4590 /* set function: MessageFont of class CUserInterface */
4591 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_MessageFont_ptr
4592 static int tolua_set_CUserInterface_MessageFont_ptr(lua_State* tolua_S)
4593 {
4594 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4595 #ifndef TOLUA_RELEASE
4596 tolua_Error tolua_err;
4597 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MessageFont'",NULL);
4598 if (!tolua_isusertype(tolua_S,2,"CFont",0,&tolua_err))
4599 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4600 #endif
4601 self->MessageFont = ((CFont*) tolua_tousertype(tolua_S,2,0))
4602 ;
4603 return 0;
4604 }
4605 #endif //#ifndef TOLUA_DISABLE
4606
4607 /* get function: MessageScrollSpeed of class CUserInterface */
4608 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_MessageScrollSpeed
4609 static int tolua_get_CUserInterface_MessageScrollSpeed(lua_State* tolua_S)
4610 {
4611 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4612 #ifndef TOLUA_RELEASE
4613 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MessageScrollSpeed'",NULL);
4614 #endif
4615 tolua_pushnumber(tolua_S,(lua_Number)self->MessageScrollSpeed);
4616 return 1;
4617 }
4618 #endif //#ifndef TOLUA_DISABLE
4619
4620 /* set function: MessageScrollSpeed of class CUserInterface */
4621 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_MessageScrollSpeed
4622 static int tolua_set_CUserInterface_MessageScrollSpeed(lua_State* tolua_S)
4623 {
4624 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4625 #ifndef TOLUA_RELEASE
4626 tolua_Error tolua_err;
4627 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MessageScrollSpeed'",NULL);
4628 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4629 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4630 #endif
4631 self->MessageScrollSpeed = ((int) tolua_tonumber(tolua_S,2,0))
4632 ;
4633 return 0;
4634 }
4635 #endif //#ifndef TOLUA_DISABLE
4636
4637 /* get function: MenuButton of class CUserInterface */
4638 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_MenuButton
4639 static int tolua_get_CUserInterface_MenuButton(lua_State* tolua_S)
4640 {
4641 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4642 #ifndef TOLUA_RELEASE
4643 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MenuButton'",NULL);
4644 #endif
4645 tolua_pushusertype(tolua_S,(void*)&self->MenuButton,"CUIButton");
4646 return 1;
4647 }
4648 #endif //#ifndef TOLUA_DISABLE
4649
4650 /* set function: MenuButton of class CUserInterface */
4651 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_MenuButton
4652 static int tolua_set_CUserInterface_MenuButton(lua_State* tolua_S)
4653 {
4654 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4655 #ifndef TOLUA_RELEASE
4656 tolua_Error tolua_err;
4657 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MenuButton'",NULL);
4658 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CUIButton",0,&tolua_err)))
4659 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4660 #endif
4661 self->MenuButton = *((CUIButton*) tolua_tousertype(tolua_S,2,0))
4662 ;
4663 return 0;
4664 }
4665 #endif //#ifndef TOLUA_DISABLE
4666
4667 /* get function: NetworkMenuButton of class CUserInterface */
4668 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_NetworkMenuButton
4669 static int tolua_get_CUserInterface_NetworkMenuButton(lua_State* tolua_S)
4670 {
4671 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4672 #ifndef TOLUA_RELEASE
4673 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NetworkMenuButton'",NULL);
4674 #endif
4675 tolua_pushusertype(tolua_S,(void*)&self->NetworkMenuButton,"CUIButton");
4676 return 1;
4677 }
4678 #endif //#ifndef TOLUA_DISABLE
4679
4680 /* set function: NetworkMenuButton of class CUserInterface */
4681 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_NetworkMenuButton
4682 static int tolua_set_CUserInterface_NetworkMenuButton(lua_State* tolua_S)
4683 {
4684 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4685 #ifndef TOLUA_RELEASE
4686 tolua_Error tolua_err;
4687 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NetworkMenuButton'",NULL);
4688 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CUIButton",0,&tolua_err)))
4689 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4690 #endif
4691 self->NetworkMenuButton = *((CUIButton*) tolua_tousertype(tolua_S,2,0))
4692 ;
4693 return 0;
4694 }
4695 #endif //#ifndef TOLUA_DISABLE
4696
4697 /* get function: NetworkDiplomacyButton of class CUserInterface */
4698 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_NetworkDiplomacyButton
4699 static int tolua_get_CUserInterface_NetworkDiplomacyButton(lua_State* tolua_S)
4700 {
4701 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4702 #ifndef TOLUA_RELEASE
4703 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NetworkDiplomacyButton'",NULL);
4704 #endif
4705 tolua_pushusertype(tolua_S,(void*)&self->NetworkDiplomacyButton,"CUIButton");
4706 return 1;
4707 }
4708 #endif //#ifndef TOLUA_DISABLE
4709
4710 /* set function: NetworkDiplomacyButton of class CUserInterface */
4711 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_NetworkDiplomacyButton
4712 static int tolua_set_CUserInterface_NetworkDiplomacyButton(lua_State* tolua_S)
4713 {
4714 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4715 #ifndef TOLUA_RELEASE
4716 tolua_Error tolua_err;
4717 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NetworkDiplomacyButton'",NULL);
4718 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CUIButton",0,&tolua_err)))
4719 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4720 #endif
4721 self->NetworkDiplomacyButton = *((CUIButton*) tolua_tousertype(tolua_S,2,0))
4722 ;
4723 return 0;
4724 }
4725 #endif //#ifndef TOLUA_DISABLE
4726
4727 /* get function: Minimap of class CUserInterface */
4728 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_Minimap
4729 static int tolua_get_CUserInterface_Minimap(lua_State* tolua_S)
4730 {
4731 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4732 #ifndef TOLUA_RELEASE
4733 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Minimap'",NULL);
4734 #endif
4735 tolua_pushusertype(tolua_S,(void*)&self->Minimap,"CMinimap");
4736 return 1;
4737 }
4738 #endif //#ifndef TOLUA_DISABLE
4739
4740 /* set function: Minimap of class CUserInterface */
4741 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_Minimap
4742 static int tolua_set_CUserInterface_Minimap(lua_State* tolua_S)
4743 {
4744 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4745 #ifndef TOLUA_RELEASE
4746 tolua_Error tolua_err;
4747 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Minimap'",NULL);
4748 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CMinimap",0,&tolua_err)))
4749 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4750 #endif
4751 self->Minimap = *((CMinimap*) tolua_tousertype(tolua_S,2,0))
4752 ;
4753 return 0;
4754 }
4755 #endif //#ifndef TOLUA_DISABLE
4756
4757 /* get function: StatusLine of class CUserInterface */
4758 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_StatusLine
4759 static int tolua_get_CUserInterface_StatusLine(lua_State* tolua_S)
4760 {
4761 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4762 #ifndef TOLUA_RELEASE
4763 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'StatusLine'",NULL);
4764 #endif
4765 tolua_pushusertype(tolua_S,(void*)&self->StatusLine,"CStatusLine");
4766 return 1;
4767 }
4768 #endif //#ifndef TOLUA_DISABLE
4769
4770 /* set function: StatusLine of class CUserInterface */
4771 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_StatusLine
4772 static int tolua_set_CUserInterface_StatusLine(lua_State* tolua_S)
4773 {
4774 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4775 #ifndef TOLUA_RELEASE
4776 tolua_Error tolua_err;
4777 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'StatusLine'",NULL);
4778 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CStatusLine",0,&tolua_err)))
4779 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4780 #endif
4781 self->StatusLine = *((CStatusLine*) tolua_tousertype(tolua_S,2,0))
4782 ;
4783 return 0;
4784 }
4785 #endif //#ifndef TOLUA_DISABLE
4786
4787 /* get function: Timer of class CUserInterface */
4788 #ifndef TOLUA_DISABLE_tolua_get_CUserInterface_Timer
4789 static int tolua_get_CUserInterface_Timer(lua_State* tolua_S)
4790 {
4791 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4792 #ifndef TOLUA_RELEASE
4793 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Timer'",NULL);
4794 #endif
4795 tolua_pushusertype(tolua_S,(void*)&self->Timer,"CUITimer");
4796 return 1;
4797 }
4798 #endif //#ifndef TOLUA_DISABLE
4799
4800 /* set function: Timer of class CUserInterface */
4801 #ifndef TOLUA_DISABLE_tolua_set_CUserInterface_Timer
4802 static int tolua_set_CUserInterface_Timer(lua_State* tolua_S)
4803 {
4804 CUserInterface* self = (CUserInterface*) tolua_tousertype(tolua_S,1,0);
4805 #ifndef TOLUA_RELEASE
4806 tolua_Error tolua_err;
4807 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Timer'",NULL);
4808 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CUITimer",0,&tolua_err)))
4809 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4810 #endif
4811 self->Timer = *((CUITimer*) tolua_tousertype(tolua_S,2,0))
4812 ;
4813 return 0;
4814 }
4815 #endif //#ifndef TOLUA_DISABLE
4816
4817 /* get function: UI */
4818 #ifndef TOLUA_DISABLE_tolua_get_UI
4819 static int tolua_get_UI(lua_State* tolua_S)
4820 {
4821 tolua_pushusertype(tolua_S,(void*)&UI,"CUserInterface");
4822 return 1;
4823 }
4824 #endif //#ifndef TOLUA_DISABLE
4825
4826 /* set function: UI */
4827 #ifndef TOLUA_DISABLE_tolua_set_UI
4828 static int tolua_set_UI(lua_State* tolua_S)
4829 {
4830 #ifndef TOLUA_RELEASE
4831 tolua_Error tolua_err;
4832 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CUserInterface",0,&tolua_err)))
4833 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4834 #endif
4835 UI = *((CUserInterface*) tolua_tousertype(tolua_S,2,0))
4836 ;
4837 return 0;
4838 }
4839 #endif //#ifndef TOLUA_DISABLE
4840
4841 /* method: New of class CIcon */
4842 #ifndef TOLUA_DISABLE_tolua_stratagus_CIcon_New00
4843 static int tolua_stratagus_CIcon_New00(lua_State* tolua_S)
4844 {
4845 #ifndef TOLUA_RELEASE
4846 tolua_Error tolua_err;
4847 if (
4848 !tolua_isusertable(tolua_S,1,"CIcon",0,&tolua_err) ||
4849 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
4850 !tolua_isnoobj(tolua_S,3,&tolua_err)
4851 )
4852 goto tolua_lerror;
4853 else
4854 #endif
4855 {
4856 const std::string ident = ((const std::string) tolua_tocppstring(tolua_S,2,0));
4857 {
4858 CIcon* tolua_ret = (CIcon*) CIcon::New(ident);
4859 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CIcon");
4860 }
4861 }
4862 return 1;
4863 #ifndef TOLUA_RELEASE
4864 tolua_lerror:
4865 tolua_error(tolua_S,"#ferror in function 'New'.",&tolua_err);
4866 return 0;
4867 #endif
4868 }
4869 #endif //#ifndef TOLUA_DISABLE
4870
4871 /* method: Get of class CIcon */
4872 #ifndef TOLUA_DISABLE_tolua_stratagus_CIcon_Get00
4873 static int tolua_stratagus_CIcon_Get00(lua_State* tolua_S)
4874 {
4875 #ifndef TOLUA_RELEASE
4876 tolua_Error tolua_err;
4877 if (
4878 !tolua_isusertable(tolua_S,1,"CIcon",0,&tolua_err) ||
4879 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
4880 !tolua_isnoobj(tolua_S,3,&tolua_err)
4881 )
4882 goto tolua_lerror;
4883 else
4884 #endif
4885 {
4886 const std::string ident = ((const std::string) tolua_tocppstring(tolua_S,2,0));
4887 {
4888 CIcon* tolua_ret = (CIcon*) CIcon::Get(ident);
4889 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CIcon");
4890 }
4891 }
4892 return 1;
4893 #ifndef TOLUA_RELEASE
4894 tolua_lerror:
4895 tolua_error(tolua_S,"#ferror in function 'Get'.",&tolua_err);
4896 return 0;
4897 #endif
4898 }
4899 #endif //#ifndef TOLUA_DISABLE
4900
4901 /* get function: Ident of class CIcon */
4902 #ifndef TOLUA_DISABLE_tolua_get_CIcon_Ident
4903 static int tolua_get_CIcon_Ident(lua_State* tolua_S)
4904 {
4905 CIcon* self = (CIcon*) tolua_tousertype(tolua_S,1,0);
4906 #ifndef TOLUA_RELEASE
4907 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Ident'",NULL);
4908 #endif
4909 tolua_pushcppstring(tolua_S,(const char*)self->GetIdent());
4910 return 1;
4911 }
4912 #endif //#ifndef TOLUA_DISABLE
4913
4914 /* get function: G of class CIcon */
4915 #ifndef TOLUA_DISABLE_tolua_get_CIcon_G_ptr
4916 static int tolua_get_CIcon_G_ptr(lua_State* tolua_S)
4917 {
4918 CIcon* self = (CIcon*) tolua_tousertype(tolua_S,1,0);
4919 #ifndef TOLUA_RELEASE
4920 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
4921 #endif
4922 tolua_pushusertype(tolua_S,(void*)self->G,"CGraphic");
4923 return 1;
4924 }
4925 #endif //#ifndef TOLUA_DISABLE
4926
4927 /* set function: G of class CIcon */
4928 #ifndef TOLUA_DISABLE_tolua_set_CIcon_G_ptr
4929 static int tolua_set_CIcon_G_ptr(lua_State* tolua_S)
4930 {
4931 CIcon* self = (CIcon*) tolua_tousertype(tolua_S,1,0);
4932 #ifndef TOLUA_RELEASE
4933 tolua_Error tolua_err;
4934 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
4935 if (!tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err))
4936 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4937 #endif
4938 self->G = ((CGraphic*) tolua_tousertype(tolua_S,2,0))
4939 ;
4940 return 0;
4941 }
4942 #endif //#ifndef TOLUA_DISABLE
4943
4944 /* get function: Frame of class CIcon */
4945 #ifndef TOLUA_DISABLE_tolua_get_CIcon_Frame
4946 static int tolua_get_CIcon_Frame(lua_State* tolua_S)
4947 {
4948 CIcon* self = (CIcon*) tolua_tousertype(tolua_S,1,0);
4949 #ifndef TOLUA_RELEASE
4950 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Frame'",NULL);
4951 #endif
4952 tolua_pushnumber(tolua_S,(lua_Number)self->Frame);
4953 return 1;
4954 }
4955 #endif //#ifndef TOLUA_DISABLE
4956
4957 /* set function: Frame of class CIcon */
4958 #ifndef TOLUA_DISABLE_tolua_set_CIcon_Frame
4959 static int tolua_set_CIcon_Frame(lua_State* tolua_S)
4960 {
4961 CIcon* self = (CIcon*) tolua_tousertype(tolua_S,1,0);
4962 #ifndef TOLUA_RELEASE
4963 tolua_Error tolua_err;
4964 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Frame'",NULL);
4965 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4966 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4967 #endif
4968 self->Frame = ((int) tolua_tonumber(tolua_S,2,0))
4969 ;
4970 return 0;
4971 }
4972 #endif //#ifndef TOLUA_DISABLE
4973
4974 /* function: FindButtonStyle */
4975 #ifndef TOLUA_DISABLE_tolua_stratagus_FindButtonStyle00
4976 static int tolua_stratagus_FindButtonStyle00(lua_State* tolua_S)
4977 {
4978 #ifndef TOLUA_RELEASE
4979 tolua_Error tolua_err;
4980 if (
4981 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
4982 !tolua_isnoobj(tolua_S,2,&tolua_err)
4983 )
4984 goto tolua_lerror;
4985 else
4986 #endif
4987 {
4988 const std::string style = ((const std::string) tolua_tocppstring(tolua_S,1,0));
4989 {
4990 ButtonStyle* tolua_ret = (ButtonStyle*) FindButtonStyle(style);
4991 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ButtonStyle");
4992 }
4993 }
4994 return 1;
4995 #ifndef TOLUA_RELEASE
4996 tolua_lerror:
4997 tolua_error(tolua_S,"#ferror in function 'FindButtonStyle'.",&tolua_err);
4998 return 0;
4999 #endif
5000 }
5001 #endif //#ifndef TOLUA_DISABLE
5002
5003 /* function: GetMouseScroll */
5004 #ifndef TOLUA_DISABLE_tolua_stratagus_GetMouseScroll00
5005 static int tolua_stratagus_GetMouseScroll00(lua_State* tolua_S)
5006 {
5007 #ifndef TOLUA_RELEASE
5008 tolua_Error tolua_err;
5009 if (
5010 !tolua_isnoobj(tolua_S,1,&tolua_err)
5011 )
5012 goto tolua_lerror;
5013 else
5014 #endif
5015 {
5016 {
5017 bool tolua_ret = (bool) GetMouseScroll();
5018 tolua_pushboolean(tolua_S,(bool)tolua_ret);
5019 }
5020 }
5021 return 1;
5022 #ifndef TOLUA_RELEASE
5023 tolua_lerror:
5024 tolua_error(tolua_S,"#ferror in function 'GetMouseScroll'.",&tolua_err);
5025 return 0;
5026 #endif
5027 }
5028 #endif //#ifndef TOLUA_DISABLE
5029
5030 /* function: SetMouseScroll */
5031 #ifndef TOLUA_DISABLE_tolua_stratagus_SetMouseScroll00
5032 static int tolua_stratagus_SetMouseScroll00(lua_State* tolua_S)
5033 {
5034 #ifndef TOLUA_RELEASE
5035 tolua_Error tolua_err;
5036 if (
5037 !tolua_isboolean(tolua_S,1,0,&tolua_err) ||
5038 !tolua_isnoobj(tolua_S,2,&tolua_err)
5039 )
5040 goto tolua_lerror;
5041 else
5042 #endif
5043 {
5044 bool enabled = ((bool) tolua_toboolean(tolua_S,1,0));
5045 {
5046 SetMouseScroll(enabled);
5047 }
5048 }
5049 return 0;
5050 #ifndef TOLUA_RELEASE
5051 tolua_lerror:
5052 tolua_error(tolua_S,"#ferror in function 'SetMouseScroll'.",&tolua_err);
5053 return 0;
5054 #endif
5055 }
5056 #endif //#ifndef TOLUA_DISABLE
5057
5058 /* function: GetKeyScroll */
5059 #ifndef TOLUA_DISABLE_tolua_stratagus_GetKeyScroll00
5060 static int tolua_stratagus_GetKeyScroll00(lua_State* tolua_S)
5061 {
5062 #ifndef TOLUA_RELEASE
5063 tolua_Error tolua_err;
5064 if (
5065 !tolua_isnoobj(tolua_S,1,&tolua_err)
5066 )
5067 goto tolua_lerror;
5068 else
5069 #endif
5070 {
5071 {
5072 bool tolua_ret = (bool) GetKeyScroll();
5073 tolua_pushboolean(tolua_S,(bool)tolua_ret);
5074 }
5075 }
5076 return 1;
5077 #ifndef TOLUA_RELEASE
5078 tolua_lerror:
5079 tolua_error(tolua_S,"#ferror in function 'GetKeyScroll'.",&tolua_err);
5080 return 0;
5081 #endif
5082 }
5083 #endif //#ifndef TOLUA_DISABLE
5084
5085 /* function: SetKeyScroll */
5086 #ifndef TOLUA_DISABLE_tolua_stratagus_SetKeyScroll00
5087 static int tolua_stratagus_SetKeyScroll00(lua_State* tolua_S)
5088 {
5089 #ifndef TOLUA_RELEASE
5090 tolua_Error tolua_err;
5091 if (
5092 !tolua_isboolean(tolua_S,1,0,&tolua_err) ||
5093 !tolua_isnoobj(tolua_S,2,&tolua_err)
5094 )
5095 goto tolua_lerror;
5096 else
5097 #endif
5098 {
5099 bool enabled = ((bool) tolua_toboolean(tolua_S,1,0));
5100 {
5101 SetKeyScroll(enabled);
5102 }
5103 }
5104 return 0;
5105 #ifndef TOLUA_RELEASE
5106 tolua_lerror:
5107 tolua_error(tolua_S,"#ferror in function 'SetKeyScroll'.",&tolua_err);
5108 return 0;
5109 #endif
5110 }
5111 #endif //#ifndef TOLUA_DISABLE
5112
5113 /* function: GetGrabMouse */
5114 #ifndef TOLUA_DISABLE_tolua_stratagus_GetGrabMouse00
5115 static int tolua_stratagus_GetGrabMouse00(lua_State* tolua_S)
5116 {
5117 #ifndef TOLUA_RELEASE
5118 tolua_Error tolua_err;
5119 if (
5120 !tolua_isnoobj(tolua_S,1,&tolua_err)
5121 )
5122 goto tolua_lerror;
5123 else
5124 #endif
5125 {
5126 {
5127 bool tolua_ret = (bool) GetGrabMouse();
5128 tolua_pushboolean(tolua_S,(bool)tolua_ret);
5129 }
5130 }
5131 return 1;
5132 #ifndef TOLUA_RELEASE
5133 tolua_lerror:
5134 tolua_error(tolua_S,"#ferror in function 'GetGrabMouse'.",&tolua_err);
5135 return 0;
5136 #endif
5137 }
5138 #endif //#ifndef TOLUA_DISABLE
5139
5140 /* function: SetGrabMouse */
5141 #ifndef TOLUA_DISABLE_tolua_stratagus_SetGrabMouse00
5142 static int tolua_stratagus_SetGrabMouse00(lua_State* tolua_S)
5143 {
5144 #ifndef TOLUA_RELEASE
5145 tolua_Error tolua_err;
5146 if (
5147 !tolua_isboolean(tolua_S,1,0,&tolua_err) ||
5148 !tolua_isnoobj(tolua_S,2,&tolua_err)
5149 )
5150 goto tolua_lerror;
5151 else
5152 #endif
5153 {
5154 bool enabled = ((bool) tolua_toboolean(tolua_S,1,0));
5155 {
5156 SetGrabMouse(enabled);
5157 }
5158 }
5159 return 0;
5160 #ifndef TOLUA_RELEASE
5161 tolua_lerror:
5162 tolua_error(tolua_S,"#ferror in function 'SetGrabMouse'.",&tolua_err);
5163 return 0;
5164 #endif
5165 }
5166 #endif //#ifndef TOLUA_DISABLE
5167
5168 /* function: GetLeaveStops */
5169 #ifndef TOLUA_DISABLE_tolua_stratagus_GetLeaveStops00
5170 static int tolua_stratagus_GetLeaveStops00(lua_State* tolua_S)
5171 {
5172 #ifndef TOLUA_RELEASE
5173 tolua_Error tolua_err;
5174 if (
5175 !tolua_isnoobj(tolua_S,1,&tolua_err)
5176 )
5177 goto tolua_lerror;
5178 else
5179 #endif
5180 {
5181 {
5182 bool tolua_ret = (bool) GetLeaveStops();
5183 tolua_pushboolean(tolua_S,(bool)tolua_ret);
5184 }
5185 }
5186 return 1;
5187 #ifndef TOLUA_RELEASE
5188 tolua_lerror:
5189 tolua_error(tolua_S,"#ferror in function 'GetLeaveStops'.",&tolua_err);
5190 return 0;
5191 #endif
5192 }
5193 #endif //#ifndef TOLUA_DISABLE
5194
5195 /* function: SetLeaveStops */
5196 #ifndef TOLUA_DISABLE_tolua_stratagus_SetLeaveStops00
5197 static int tolua_stratagus_SetLeaveStops00(lua_State* tolua_S)
5198 {
5199 #ifndef TOLUA_RELEASE
5200 tolua_Error tolua_err;
5201 if (
5202 !tolua_isboolean(tolua_S,1,0,&tolua_err) ||
5203 !tolua_isnoobj(tolua_S,2,&tolua_err)
5204 )
5205 goto tolua_lerror;
5206 else
5207 #endif
5208 {
5209 bool enabled = ((bool) tolua_toboolean(tolua_S,1,0));
5210 {
5211 SetLeaveStops(enabled);
5212 }
5213 }
5214 return 0;
5215 #ifndef TOLUA_RELEASE
5216 tolua_lerror:
5217 tolua_error(tolua_S,"#ferror in function 'SetLeaveStops'.",&tolua_err);
5218 return 0;
5219 #endif
5220 }
5221 #endif //#ifndef TOLUA_DISABLE
5222
5223 /* function: SetSavedMapPosition */
5224 #ifndef TOLUA_DISABLE_tolua_stratagus_SetSavedMapPosition00
5225 static int tolua_stratagus_SetSavedMapPosition00(lua_State* tolua_S)
5226 {
5227 #ifndef TOLUA_RELEASE
5228 tolua_Error tolua_err;
5229 if (
5230 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
5231 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5232 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
5233 !tolua_isnoobj(tolua_S,4,&tolua_err)
5234 )
5235 goto tolua_lerror;
5236 else
5237 #endif
5238 {
5239 int index = ((int) tolua_tonumber(tolua_S,1,0));
5240 int x = ((int) tolua_tonumber(tolua_S,2,0));
5241 int y = ((int) tolua_tonumber(tolua_S,3,0));
5242 {
5243 SetSavedMapPosition(index,x,y);
5244 }
5245 }
5246 return 0;
5247 #ifndef TOLUA_RELEASE
5248 tolua_lerror:
5249 tolua_error(tolua_S,"#ferror in function 'SetSavedMapPosition'.",&tolua_err);
5250 return 0;
5251 #endif
5252 }
5253 #endif //#ifndef TOLUA_DISABLE
5254
5255 /* function: GetDoubleClickDelay */
5256 #ifndef TOLUA_DISABLE_tolua_stratagus_GetDoubleClickDelay00
5257 static int tolua_stratagus_GetDoubleClickDelay00(lua_State* tolua_S)
5258 {
5259 #ifndef TOLUA_RELEASE
5260 tolua_Error tolua_err;
5261 if (
5262 !tolua_isnoobj(tolua_S,1,&tolua_err)
5263 )
5264 goto tolua_lerror;
5265 else
5266 #endif
5267 {
5268 {
5269 int tolua_ret = (int) GetDoubleClickDelay();
5270 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5271 }
5272 }
5273 return 1;
5274 #ifndef TOLUA_RELEASE
5275 tolua_lerror:
5276 tolua_error(tolua_S,"#ferror in function 'GetDoubleClickDelay'.",&tolua_err);
5277 return 0;
5278 #endif
5279 }
5280 #endif //#ifndef TOLUA_DISABLE
5281
5282 /* function: SetDoubleClickDelay */
5283 #ifndef TOLUA_DISABLE_tolua_stratagus_SetDoubleClickDelay00
5284 static int tolua_stratagus_SetDoubleClickDelay00(lua_State* tolua_S)
5285 {
5286 #ifndef TOLUA_RELEASE
5287 tolua_Error tolua_err;
5288 if (
5289 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
5290 !tolua_isnoobj(tolua_S,2,&tolua_err)
5291 )
5292 goto tolua_lerror;
5293 else
5294 #endif
5295 {
5296 int delay = ((int) tolua_tonumber(tolua_S,1,0));
5297 {
5298 SetDoubleClickDelay(delay);
5299 }
5300 }
5301 return 0;
5302 #ifndef TOLUA_RELEASE
5303 tolua_lerror:
5304 tolua_error(tolua_S,"#ferror in function 'SetDoubleClickDelay'.",&tolua_err);
5305 return 0;
5306 #endif
5307 }
5308 #endif //#ifndef TOLUA_DISABLE
5309
5310 /* function: GetHoldClickDelay */
5311 #ifndef TOLUA_DISABLE_tolua_stratagus_GetHoldClickDelay00
5312 static int tolua_stratagus_GetHoldClickDelay00(lua_State* tolua_S)
5313 {
5314 #ifndef TOLUA_RELEASE
5315 tolua_Error tolua_err;
5316 if (
5317 !tolua_isnoobj(tolua_S,1,&tolua_err)
5318 )
5319 goto tolua_lerror;
5320 else
5321 #endif
5322 {
5323 {
5324 int tolua_ret = (int) GetHoldClickDelay();
5325 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5326 }
5327 }
5328 return 1;
5329 #ifndef TOLUA_RELEASE
5330 tolua_lerror:
5331 tolua_error(tolua_S,"#ferror in function 'GetHoldClickDelay'.",&tolua_err);
5332 return 0;
5333 #endif
5334 }
5335 #endif //#ifndef TOLUA_DISABLE
5336
5337 /* function: SetHoldClickDelay */
5338 #ifndef TOLUA_DISABLE_tolua_stratagus_SetHoldClickDelay00
5339 static int tolua_stratagus_SetHoldClickDelay00(lua_State* tolua_S)
5340 {
5341 #ifndef TOLUA_RELEASE
5342 tolua_Error tolua_err;
5343 if (
5344 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
5345 !tolua_isnoobj(tolua_S,2,&tolua_err)
5346 )
5347 goto tolua_lerror;
5348 else
5349 #endif
5350 {
5351 int delay = ((int) tolua_tonumber(tolua_S,1,0));
5352 {
5353 SetHoldClickDelay(delay);
5354 }
5355 }
5356 return 0;
5357 #ifndef TOLUA_RELEASE
5358 tolua_lerror:
5359 tolua_error(tolua_S,"#ferror in function 'SetHoldClickDelay'.",&tolua_err);
5360 return 0;
5361 #endif
5362 }
5363 #endif //#ifndef TOLUA_DISABLE
5364
5365 /* get function: CursorX */
5366 #ifndef TOLUA_DISABLE_tolua_get_CursorX
5367 static int tolua_get_CursorX(lua_State* tolua_S)
5368 {
5369 tolua_pushnumber(tolua_S,(lua_Number)CursorX);
5370 return 1;
5371 }
5372 #endif //#ifndef TOLUA_DISABLE
5373
5374 /* set function: CursorX */
5375 #ifndef TOLUA_DISABLE_tolua_set_CursorX
5376 static int tolua_set_CursorX(lua_State* tolua_S)
5377 {
5378 #ifndef TOLUA_RELEASE
5379 tolua_Error tolua_err;
5380 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5381 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5382 #endif
5383 CursorX = ((int) tolua_tonumber(tolua_S,2,0))
5384 ;
5385 return 0;
5386 }
5387 #endif //#ifndef TOLUA_DISABLE
5388
5389 /* get function: CursorY */
5390 #ifndef TOLUA_DISABLE_tolua_get_CursorY
5391 static int tolua_get_CursorY(lua_State* tolua_S)
5392 {
5393 tolua_pushnumber(tolua_S,(lua_Number)CursorY);
5394 return 1;
5395 }
5396 #endif //#ifndef TOLUA_DISABLE
5397
5398 /* set function: CursorY */
5399 #ifndef TOLUA_DISABLE_tolua_set_CursorY
5400 static int tolua_set_CursorY(lua_State* tolua_S)
5401 {
5402 #ifndef TOLUA_RELEASE
5403 tolua_Error tolua_err;
5404 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5405 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5406 #endif
5407 CursorY = ((int) tolua_tonumber(tolua_S,2,0))
5408 ;
5409 return 0;
5410 }
5411 #endif //#ifndef TOLUA_DISABLE
5412
5413 /* method: new of class Color */
5414 #ifndef TOLUA_DISABLE_tolua_stratagus_Color_new00
5415 static int tolua_stratagus_Color_new00(lua_State* tolua_S)
5416 {
5417 #ifndef TOLUA_RELEASE
5418 tolua_Error tolua_err;
5419 if (
5420 !tolua_isusertable(tolua_S,1,"Color",0,&tolua_err) ||
5421 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5422 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
5423 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
5424 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
5425 !tolua_isnoobj(tolua_S,6,&tolua_err)
5426 )
5427 goto tolua_lerror;
5428 else
5429 #endif
5430 {
5431 int r = ((int) tolua_tonumber(tolua_S,2,0));
5432 int g = ((int) tolua_tonumber(tolua_S,3,0));
5433 int b = ((int) tolua_tonumber(tolua_S,4,0));
5434 int a = ((int) tolua_tonumber(tolua_S,5,255));
5435 {
5436 Color* tolua_ret = (Color*) Mtolua_new((Color)(r,g,b,a));
5437 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Color");
5438 }
5439 }
5440 return 1;
5441 #ifndef TOLUA_RELEASE
5442 tolua_lerror:
5443 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5444 return 0;
5445 #endif
5446 }
5447 #endif //#ifndef TOLUA_DISABLE
5448
5449 /* method: new_local of class Color */
5450 #ifndef TOLUA_DISABLE_tolua_stratagus_Color_new00_local
5451 static int tolua_stratagus_Color_new00_local(lua_State* tolua_S)
5452 {
5453 #ifndef TOLUA_RELEASE
5454 tolua_Error tolua_err;
5455 if (
5456 !tolua_isusertable(tolua_S,1,"Color",0,&tolua_err) ||
5457 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5458 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
5459 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
5460 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
5461 !tolua_isnoobj(tolua_S,6,&tolua_err)
5462 )
5463 goto tolua_lerror;
5464 else
5465 #endif
5466 {
5467 int r = ((int) tolua_tonumber(tolua_S,2,0));
5468 int g = ((int) tolua_tonumber(tolua_S,3,0));
5469 int b = ((int) tolua_tonumber(tolua_S,4,0));
5470 int a = ((int) tolua_tonumber(tolua_S,5,255));
5471 {
5472 Color* tolua_ret = (Color*) Mtolua_new((Color)(r,g,b,a));
5473 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Color");
5474 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5475 }
5476 }
5477 return 1;
5478 #ifndef TOLUA_RELEASE
5479 tolua_lerror:
5480 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5481 return 0;
5482 #endif
5483 }
5484 #endif //#ifndef TOLUA_DISABLE
5485
5486 /* get function: r of class Color */
5487 #ifndef TOLUA_DISABLE_tolua_get_Color_r
5488 static int tolua_get_Color_r(lua_State* tolua_S)
5489 {
5490 Color* self = (Color*) tolua_tousertype(tolua_S,1,0);
5491 #ifndef TOLUA_RELEASE
5492 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'r'",NULL);
5493 #endif
5494 tolua_pushnumber(tolua_S,(lua_Number)self->r);
5495 return 1;
5496 }
5497 #endif //#ifndef TOLUA_DISABLE
5498
5499 /* set function: r of class Color */
5500 #ifndef TOLUA_DISABLE_tolua_set_Color_r
5501 static int tolua_set_Color_r(lua_State* tolua_S)
5502 {
5503 Color* self = (Color*) tolua_tousertype(tolua_S,1,0);
5504 #ifndef TOLUA_RELEASE
5505 tolua_Error tolua_err;
5506 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'r'",NULL);
5507 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5508 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5509 #endif
5510 self->r = ((int) tolua_tonumber(tolua_S,2,0))
5511 ;
5512 return 0;
5513 }
5514 #endif //#ifndef TOLUA_DISABLE
5515
5516 /* get function: g of class Color */
5517 #ifndef TOLUA_DISABLE_tolua_get_Color_g
5518 static int tolua_get_Color_g(lua_State* tolua_S)
5519 {
5520 Color* self = (Color*) tolua_tousertype(tolua_S,1,0);
5521 #ifndef TOLUA_RELEASE
5522 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'g'",NULL);
5523 #endif
5524 tolua_pushnumber(tolua_S,(lua_Number)self->g);
5525 return 1;
5526 }
5527 #endif //#ifndef TOLUA_DISABLE
5528
5529 /* set function: g of class Color */
5530 #ifndef TOLUA_DISABLE_tolua_set_Color_g
5531 static int tolua_set_Color_g(lua_State* tolua_S)
5532 {
5533 Color* self = (Color*) tolua_tousertype(tolua_S,1,0);
5534 #ifndef TOLUA_RELEASE
5535 tolua_Error tolua_err;
5536 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'g'",NULL);
5537 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5538 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5539 #endif
5540 self->g = ((int) tolua_tonumber(tolua_S,2,0))
5541 ;
5542 return 0;
5543 }
5544 #endif //#ifndef TOLUA_DISABLE
5545
5546 /* get function: b of class Color */
5547 #ifndef TOLUA_DISABLE_tolua_get_Color_b
5548 static int tolua_get_Color_b(lua_State* tolua_S)
5549 {
5550 Color* self = (Color*) tolua_tousertype(tolua_S,1,0);
5551 #ifndef TOLUA_RELEASE
5552 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'b'",NULL);
5553 #endif
5554 tolua_pushnumber(tolua_S,(lua_Number)self->b);
5555 return 1;
5556 }
5557 #endif //#ifndef TOLUA_DISABLE
5558
5559 /* set function: b of class Color */
5560 #ifndef TOLUA_DISABLE_tolua_set_Color_b
5561 static int tolua_set_Color_b(lua_State* tolua_S)
5562 {
5563 Color* self = (Color*) tolua_tousertype(tolua_S,1,0);
5564 #ifndef TOLUA_RELEASE
5565 tolua_Error tolua_err;
5566 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'b'",NULL);
5567 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5568 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5569 #endif
5570 self->b = ((int) tolua_tonumber(tolua_S,2,0))
5571 ;
5572 return 0;
5573 }
5574 #endif //#ifndef TOLUA_DISABLE
5575
5576 /* get function: a of class Color */
5577 #ifndef TOLUA_DISABLE_tolua_get_Color_a
5578 static int tolua_get_Color_a(lua_State* tolua_S)
5579 {
5580 Color* self = (Color*) tolua_tousertype(tolua_S,1,0);
5581 #ifndef TOLUA_RELEASE
5582 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'a'",NULL);
5583 #endif
5584 tolua_pushnumber(tolua_S,(lua_Number)self->a);
5585 return 1;
5586 }
5587 #endif //#ifndef TOLUA_DISABLE
5588
5589 /* set function: a of class Color */
5590 #ifndef TOLUA_DISABLE_tolua_set_Color_a
5591 static int tolua_set_Color_a(lua_State* tolua_S)
5592 {
5593 Color* self = (Color*) tolua_tousertype(tolua_S,1,0);
5594 #ifndef TOLUA_RELEASE
5595 tolua_Error tolua_err;
5596 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'a'",NULL);
5597 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5598 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5599 #endif
5600 self->a = ((int) tolua_tonumber(tolua_S,2,0))
5601 ;
5602 return 0;
5603 }
5604 #endif //#ifndef TOLUA_DISABLE
5605
5606 /* method: setWidth of class Widget */
5607 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setWidth00
5608 static int tolua_stratagus_Widget_setWidth00(lua_State* tolua_S)
5609 {
5610 #ifndef TOLUA_RELEASE
5611 tolua_Error tolua_err;
5612 if (
5613 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
5614 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5615 !tolua_isnoobj(tolua_S,3,&tolua_err)
5616 )
5617 goto tolua_lerror;
5618 else
5619 #endif
5620 {
5621 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
5622 int width = ((int) tolua_tonumber(tolua_S,2,0));
5623 #ifndef TOLUA_RELEASE
5624 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWidth'", NULL);
5625 #endif
5626 {
5627 self->setWidth(width);
5628 }
5629 }
5630 return 0;
5631 #ifndef TOLUA_RELEASE
5632 tolua_lerror:
5633 tolua_error(tolua_S,"#ferror in function 'setWidth'.",&tolua_err);
5634 return 0;
5635 #endif
5636 }
5637 #endif //#ifndef TOLUA_DISABLE
5638
5639 /* method: getWidth of class Widget */
5640 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getWidth00
5641 static int tolua_stratagus_Widget_getWidth00(lua_State* tolua_S)
5642 {
5643 #ifndef TOLUA_RELEASE
5644 tolua_Error tolua_err;
5645 if (
5646 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
5647 !tolua_isnoobj(tolua_S,2,&tolua_err)
5648 )
5649 goto tolua_lerror;
5650 else
5651 #endif
5652 {
5653 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
5654 #ifndef TOLUA_RELEASE
5655 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidth'", NULL);
5656 #endif
5657 {
5658 int tolua_ret = (int) self->getWidth();
5659 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5660 }
5661 }
5662 return 1;
5663 #ifndef TOLUA_RELEASE
5664 tolua_lerror:
5665 tolua_error(tolua_S,"#ferror in function 'getWidth'.",&tolua_err);
5666 return 0;
5667 #endif
5668 }
5669 #endif //#ifndef TOLUA_DISABLE
5670
5671 /* method: setHeight of class Widget */
5672 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setHeight00
5673 static int tolua_stratagus_Widget_setHeight00(lua_State* tolua_S)
5674 {
5675 #ifndef TOLUA_RELEASE
5676 tolua_Error tolua_err;
5677 if (
5678 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
5679 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5680 !tolua_isnoobj(tolua_S,3,&tolua_err)
5681 )
5682 goto tolua_lerror;
5683 else
5684 #endif
5685 {
5686 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
5687 int height = ((int) tolua_tonumber(tolua_S,2,0));
5688 #ifndef TOLUA_RELEASE
5689 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHeight'", NULL);
5690 #endif
5691 {
5692 self->setHeight(height);
5693 }
5694 }
5695 return 0;
5696 #ifndef TOLUA_RELEASE
5697 tolua_lerror:
5698 tolua_error(tolua_S,"#ferror in function 'setHeight'.",&tolua_err);
5699 return 0;
5700 #endif
5701 }
5702 #endif //#ifndef TOLUA_DISABLE
5703
5704 /* method: getHeight of class Widget */
5705 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getHeight00
5706 static int tolua_stratagus_Widget_getHeight00(lua_State* tolua_S)
5707 {
5708 #ifndef TOLUA_RELEASE
5709 tolua_Error tolua_err;
5710 if (
5711 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
5712 !tolua_isnoobj(tolua_S,2,&tolua_err)
5713 )
5714 goto tolua_lerror;
5715 else
5716 #endif
5717 {
5718 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
5719 #ifndef TOLUA_RELEASE
5720 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHeight'", NULL);
5721 #endif
5722 {
5723 int tolua_ret = (int) self->getHeight();
5724 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5725 }
5726 }
5727 return 1;
5728 #ifndef TOLUA_RELEASE
5729 tolua_lerror:
5730 tolua_error(tolua_S,"#ferror in function 'getHeight'.",&tolua_err);
5731 return 0;
5732 #endif
5733 }
5734 #endif //#ifndef TOLUA_DISABLE
5735
5736 /* method: setSize of class Widget */
5737 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setSize00
5738 static int tolua_stratagus_Widget_setSize00(lua_State* tolua_S)
5739 {
5740 #ifndef TOLUA_RELEASE
5741 tolua_Error tolua_err;
5742 if (
5743 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
5744 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5745 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
5746 !tolua_isnoobj(tolua_S,4,&tolua_err)
5747 )
5748 goto tolua_lerror;
5749 else
5750 #endif
5751 {
5752 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
5753 int width = ((int) tolua_tonumber(tolua_S,2,0));
5754 int height = ((int) tolua_tonumber(tolua_S,3,0));
5755 #ifndef TOLUA_RELEASE
5756 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSize'", NULL);
5757 #endif
5758 {
5759 self->setSize(width,height);
5760 }
5761 }
5762 return 0;
5763 #ifndef TOLUA_RELEASE
5764 tolua_lerror:
5765 tolua_error(tolua_S,"#ferror in function 'setSize'.",&tolua_err);
5766 return 0;
5767 #endif
5768 }
5769 #endif //#ifndef TOLUA_DISABLE
5770
5771 /* method: setX of class Widget */
5772 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setX00
5773 static int tolua_stratagus_Widget_setX00(lua_State* tolua_S)
5774 {
5775 #ifndef TOLUA_RELEASE
5776 tolua_Error tolua_err;
5777 if (
5778 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
5779 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5780 !tolua_isnoobj(tolua_S,3,&tolua_err)
5781 )
5782 goto tolua_lerror;
5783 else
5784 #endif
5785 {
5786 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
5787 int x = ((int) tolua_tonumber(tolua_S,2,0));
5788 #ifndef TOLUA_RELEASE
5789 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setX'", NULL);
5790 #endif
5791 {
5792 self->setX(x);
5793 }
5794 }
5795 return 0;
5796 #ifndef TOLUA_RELEASE
5797 tolua_lerror:
5798 tolua_error(tolua_S,"#ferror in function 'setX'.",&tolua_err);
5799 return 0;
5800 #endif
5801 }
5802 #endif //#ifndef TOLUA_DISABLE
5803
5804 /* method: getX of class Widget */
5805 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getX00
5806 static int tolua_stratagus_Widget_getX00(lua_State* tolua_S)
5807 {
5808 #ifndef TOLUA_RELEASE
5809 tolua_Error tolua_err;
5810 if (
5811 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
5812 !tolua_isnoobj(tolua_S,2,&tolua_err)
5813 )
5814 goto tolua_lerror;
5815 else
5816 #endif
5817 {
5818 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
5819 #ifndef TOLUA_RELEASE
5820 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getX'", NULL);
5821 #endif
5822 {
5823 int tolua_ret = (int) self->getX();
5824 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5825 }
5826 }
5827 return 1;
5828 #ifndef TOLUA_RELEASE
5829 tolua_lerror:
5830 tolua_error(tolua_S,"#ferror in function 'getX'.",&tolua_err);
5831 return 0;
5832 #endif
5833 }
5834 #endif //#ifndef TOLUA_DISABLE
5835
5836 /* method: setY of class Widget */
5837 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setY00
5838 static int tolua_stratagus_Widget_setY00(lua_State* tolua_S)
5839 {
5840 #ifndef TOLUA_RELEASE
5841 tolua_Error tolua_err;
5842 if (
5843 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
5844 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5845 !tolua_isnoobj(tolua_S,3,&tolua_err)
5846 )
5847 goto tolua_lerror;
5848 else
5849 #endif
5850 {
5851 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
5852 int y = ((int) tolua_tonumber(tolua_S,2,0));
5853 #ifndef TOLUA_RELEASE
5854 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setY'", NULL);
5855 #endif
5856 {
5857 self->setY(y);
5858 }
5859 }
5860 return 0;
5861 #ifndef TOLUA_RELEASE
5862 tolua_lerror:
5863 tolua_error(tolua_S,"#ferror in function 'setY'.",&tolua_err);
5864 return 0;
5865 #endif
5866 }
5867 #endif //#ifndef TOLUA_DISABLE
5868
5869 /* method: getY of class Widget */
5870 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getY00
5871 static int tolua_stratagus_Widget_getY00(lua_State* tolua_S)
5872 {
5873 #ifndef TOLUA_RELEASE
5874 tolua_Error tolua_err;
5875 if (
5876 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
5877 !tolua_isnoobj(tolua_S,2,&tolua_err)
5878 )
5879 goto tolua_lerror;
5880 else
5881 #endif
5882 {
5883 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
5884 #ifndef TOLUA_RELEASE
5885 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getY'", NULL);
5886 #endif
5887 {
5888 int tolua_ret = (int) self->getY();
5889 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5890 }
5891 }
5892 return 1;
5893 #ifndef TOLUA_RELEASE
5894 tolua_lerror:
5895 tolua_error(tolua_S,"#ferror in function 'getY'.",&tolua_err);
5896 return 0;
5897 #endif
5898 }
5899 #endif //#ifndef TOLUA_DISABLE
5900
5901 /* method: setPosition of class Widget */
5902 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setPosition00
5903 static int tolua_stratagus_Widget_setPosition00(lua_State* tolua_S)
5904 {
5905 #ifndef TOLUA_RELEASE
5906 tolua_Error tolua_err;
5907 if (
5908 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
5909 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5910 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
5911 !tolua_isnoobj(tolua_S,4,&tolua_err)
5912 )
5913 goto tolua_lerror;
5914 else
5915 #endif
5916 {
5917 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
5918 int x = ((int) tolua_tonumber(tolua_S,2,0));
5919 int y = ((int) tolua_tonumber(tolua_S,3,0));
5920 #ifndef TOLUA_RELEASE
5921 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPosition'", NULL);
5922 #endif
5923 {
5924 self->setPosition(x,y);
5925 }
5926 }
5927 return 0;
5928 #ifndef TOLUA_RELEASE
5929 tolua_lerror:
5930 tolua_error(tolua_S,"#ferror in function 'setPosition'.",&tolua_err);
5931 return 0;
5932 #endif
5933 }
5934 #endif //#ifndef TOLUA_DISABLE
5935
5936 /* method: setBorderSize of class Widget */
5937 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setBorderSize00
5938 static int tolua_stratagus_Widget_setBorderSize00(lua_State* tolua_S)
5939 {
5940 #ifndef TOLUA_RELEASE
5941 tolua_Error tolua_err;
5942 if (
5943 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
5944 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5945 !tolua_isnoobj(tolua_S,3,&tolua_err)
5946 )
5947 goto tolua_lerror;
5948 else
5949 #endif
5950 {
5951 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
5952 int width = ((int) tolua_tonumber(tolua_S,2,0));
5953 #ifndef TOLUA_RELEASE
5954 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBorderSize'", NULL);
5955 #endif
5956 {
5957 self->setBorderSize(width);
5958 }
5959 }
5960 return 0;
5961 #ifndef TOLUA_RELEASE
5962 tolua_lerror:
5963 tolua_error(tolua_S,"#ferror in function 'setBorderSize'.",&tolua_err);
5964 return 0;
5965 #endif
5966 }
5967 #endif //#ifndef TOLUA_DISABLE
5968
5969 /* method: getBorderSize of class Widget */
5970 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getBorderSize00
5971 static int tolua_stratagus_Widget_getBorderSize00(lua_State* tolua_S)
5972 {
5973 #ifndef TOLUA_RELEASE
5974 tolua_Error tolua_err;
5975 if (
5976 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
5977 !tolua_isnoobj(tolua_S,2,&tolua_err)
5978 )
5979 goto tolua_lerror;
5980 else
5981 #endif
5982 {
5983 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
5984 #ifndef TOLUA_RELEASE
5985 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBorderSize'", NULL);
5986 #endif
5987 {
5988 unsigned int tolua_ret = (unsigned int) self->getBorderSize();
5989 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5990 }
5991 }
5992 return 1;
5993 #ifndef TOLUA_RELEASE
5994 tolua_lerror:
5995 tolua_error(tolua_S,"#ferror in function 'getBorderSize'.",&tolua_err);
5996 return 0;
5997 #endif
5998 }
5999 #endif //#ifndef TOLUA_DISABLE
6000
6001 /* method: setEnabled of class Widget */
6002 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setEnabled00
6003 static int tolua_stratagus_Widget_setEnabled00(lua_State* tolua_S)
6004 {
6005 #ifndef TOLUA_RELEASE
6006 tolua_Error tolua_err;
6007 if (
6008 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6009 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
6010 !tolua_isnoobj(tolua_S,3,&tolua_err)
6011 )
6012 goto tolua_lerror;
6013 else
6014 #endif
6015 {
6016 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6017 bool enabled = ((bool) tolua_toboolean(tolua_S,2,0));
6018 #ifndef TOLUA_RELEASE
6019 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setEnabled'", NULL);
6020 #endif
6021 {
6022 self->setEnabled(enabled);
6023 }
6024 }
6025 return 0;
6026 #ifndef TOLUA_RELEASE
6027 tolua_lerror:
6028 tolua_error(tolua_S,"#ferror in function 'setEnabled'.",&tolua_err);
6029 return 0;
6030 #endif
6031 }
6032 #endif //#ifndef TOLUA_DISABLE
6033
6034 /* method: isEnabled of class Widget */
6035 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_isEnabled00
6036 static int tolua_stratagus_Widget_isEnabled00(lua_State* tolua_S)
6037 {
6038 #ifndef TOLUA_RELEASE
6039 tolua_Error tolua_err;
6040 if (
6041 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
6042 !tolua_isnoobj(tolua_S,2,&tolua_err)
6043 )
6044 goto tolua_lerror;
6045 else
6046 #endif
6047 {
6048 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
6049 #ifndef TOLUA_RELEASE
6050 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isEnabled'", NULL);
6051 #endif
6052 {
6053 bool tolua_ret = (bool) self->isEnabled();
6054 tolua_pushboolean(tolua_S,(bool)tolua_ret);
6055 }
6056 }
6057 return 1;
6058 #ifndef TOLUA_RELEASE
6059 tolua_lerror:
6060 tolua_error(tolua_S,"#ferror in function 'isEnabled'.",&tolua_err);
6061 return 0;
6062 #endif
6063 }
6064 #endif //#ifndef TOLUA_DISABLE
6065
6066 /* method: setVisible of class Widget */
6067 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setVisible00
6068 static int tolua_stratagus_Widget_setVisible00(lua_State* tolua_S)
6069 {
6070 #ifndef TOLUA_RELEASE
6071 tolua_Error tolua_err;
6072 if (
6073 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6074 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
6075 !tolua_isnoobj(tolua_S,3,&tolua_err)
6076 )
6077 goto tolua_lerror;
6078 else
6079 #endif
6080 {
6081 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6082 bool visible = ((bool) tolua_toboolean(tolua_S,2,0));
6083 #ifndef TOLUA_RELEASE
6084 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVisible'", NULL);
6085 #endif
6086 {
6087 self->setVisible(visible);
6088 }
6089 }
6090 return 0;
6091 #ifndef TOLUA_RELEASE
6092 tolua_lerror:
6093 tolua_error(tolua_S,"#ferror in function 'setVisible'.",&tolua_err);
6094 return 0;
6095 #endif
6096 }
6097 #endif //#ifndef TOLUA_DISABLE
6098
6099 /* method: isVisible of class Widget */
6100 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_isVisible00
6101 static int tolua_stratagus_Widget_isVisible00(lua_State* tolua_S)
6102 {
6103 #ifndef TOLUA_RELEASE
6104 tolua_Error tolua_err;
6105 if (
6106 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
6107 !tolua_isnoobj(tolua_S,2,&tolua_err)
6108 )
6109 goto tolua_lerror;
6110 else
6111 #endif
6112 {
6113 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
6114 #ifndef TOLUA_RELEASE
6115 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isVisible'", NULL);
6116 #endif
6117 {
6118 bool tolua_ret = (bool) self->isVisible();
6119 tolua_pushboolean(tolua_S,(bool)tolua_ret);
6120 }
6121 }
6122 return 1;
6123 #ifndef TOLUA_RELEASE
6124 tolua_lerror:
6125 tolua_error(tolua_S,"#ferror in function 'isVisible'.",&tolua_err);
6126 return 0;
6127 #endif
6128 }
6129 #endif //#ifndef TOLUA_DISABLE
6130
6131 /* method: setBaseColor of class Widget */
6132 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setBaseColor00
6133 static int tolua_stratagus_Widget_setBaseColor00(lua_State* tolua_S)
6134 {
6135 #ifndef TOLUA_RELEASE
6136 tolua_Error tolua_err;
6137 if (
6138 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6139 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Color",0,&tolua_err)) ||
6140 !tolua_isnoobj(tolua_S,3,&tolua_err)
6141 )
6142 goto tolua_lerror;
6143 else
6144 #endif
6145 {
6146 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6147 const Color color = *((const Color*) tolua_tousertype(tolua_S,2,0));
6148 #ifndef TOLUA_RELEASE
6149 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBaseColor'", NULL);
6150 #endif
6151 {
6152 self->setBaseColor(color);
6153 }
6154 }
6155 return 0;
6156 #ifndef TOLUA_RELEASE
6157 tolua_lerror:
6158 tolua_error(tolua_S,"#ferror in function 'setBaseColor'.",&tolua_err);
6159 return 0;
6160 #endif
6161 }
6162 #endif //#ifndef TOLUA_DISABLE
6163
6164 /* method: getBaseColor of class Widget */
6165 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getBaseColor00
6166 static int tolua_stratagus_Widget_getBaseColor00(lua_State* tolua_S)
6167 {
6168 #ifndef TOLUA_RELEASE
6169 tolua_Error tolua_err;
6170 if (
6171 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
6172 !tolua_isnoobj(tolua_S,2,&tolua_err)
6173 )
6174 goto tolua_lerror;
6175 else
6176 #endif
6177 {
6178 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
6179 #ifndef TOLUA_RELEASE
6180 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBaseColor'", NULL);
6181 #endif
6182 {
6183 const Color& tolua_ret = (const Color&) self->getBaseColor();
6184 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Color");
6185 }
6186 }
6187 return 1;
6188 #ifndef TOLUA_RELEASE
6189 tolua_lerror:
6190 tolua_error(tolua_S,"#ferror in function 'getBaseColor'.",&tolua_err);
6191 return 0;
6192 #endif
6193 }
6194 #endif //#ifndef TOLUA_DISABLE
6195
6196 /* method: setForegroundColor of class Widget */
6197 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setForegroundColor00
6198 static int tolua_stratagus_Widget_setForegroundColor00(lua_State* tolua_S)
6199 {
6200 #ifndef TOLUA_RELEASE
6201 tolua_Error tolua_err;
6202 if (
6203 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6204 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Color",0,&tolua_err)) ||
6205 !tolua_isnoobj(tolua_S,3,&tolua_err)
6206 )
6207 goto tolua_lerror;
6208 else
6209 #endif
6210 {
6211 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6212 const Color color = *((const Color*) tolua_tousertype(tolua_S,2,0));
6213 #ifndef TOLUA_RELEASE
6214 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setForegroundColor'", NULL);
6215 #endif
6216 {
6217 self->setForegroundColor(color);
6218 }
6219 }
6220 return 0;
6221 #ifndef TOLUA_RELEASE
6222 tolua_lerror:
6223 tolua_error(tolua_S,"#ferror in function 'setForegroundColor'.",&tolua_err);
6224 return 0;
6225 #endif
6226 }
6227 #endif //#ifndef TOLUA_DISABLE
6228
6229 /* method: getForegroundColor of class Widget */
6230 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getForegroundColor00
6231 static int tolua_stratagus_Widget_getForegroundColor00(lua_State* tolua_S)
6232 {
6233 #ifndef TOLUA_RELEASE
6234 tolua_Error tolua_err;
6235 if (
6236 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
6237 !tolua_isnoobj(tolua_S,2,&tolua_err)
6238 )
6239 goto tolua_lerror;
6240 else
6241 #endif
6242 {
6243 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
6244 #ifndef TOLUA_RELEASE
6245 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getForegroundColor'", NULL);
6246 #endif
6247 {
6248 const Color& tolua_ret = (const Color&) self->getForegroundColor();
6249 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Color");
6250 }
6251 }
6252 return 1;
6253 #ifndef TOLUA_RELEASE
6254 tolua_lerror:
6255 tolua_error(tolua_S,"#ferror in function 'getForegroundColor'.",&tolua_err);
6256 return 0;
6257 #endif
6258 }
6259 #endif //#ifndef TOLUA_DISABLE
6260
6261 /* method: setBackgroundColor of class Widget */
6262 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setBackgroundColor00
6263 static int tolua_stratagus_Widget_setBackgroundColor00(lua_State* tolua_S)
6264 {
6265 #ifndef TOLUA_RELEASE
6266 tolua_Error tolua_err;
6267 if (
6268 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6269 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Color",0,&tolua_err)) ||
6270 !tolua_isnoobj(tolua_S,3,&tolua_err)
6271 )
6272 goto tolua_lerror;
6273 else
6274 #endif
6275 {
6276 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6277 const Color color = *((const Color*) tolua_tousertype(tolua_S,2,0));
6278 #ifndef TOLUA_RELEASE
6279 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundColor'", NULL);
6280 #endif
6281 {
6282 self->setBackgroundColor(color);
6283 }
6284 }
6285 return 0;
6286 #ifndef TOLUA_RELEASE
6287 tolua_lerror:
6288 tolua_error(tolua_S,"#ferror in function 'setBackgroundColor'.",&tolua_err);
6289 return 0;
6290 #endif
6291 }
6292 #endif //#ifndef TOLUA_DISABLE
6293
6294 /* method: getBackgroundColor of class Widget */
6295 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getBackgroundColor00
6296 static int tolua_stratagus_Widget_getBackgroundColor00(lua_State* tolua_S)
6297 {
6298 #ifndef TOLUA_RELEASE
6299 tolua_Error tolua_err;
6300 if (
6301 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
6302 !tolua_isnoobj(tolua_S,2,&tolua_err)
6303 )
6304 goto tolua_lerror;
6305 else
6306 #endif
6307 {
6308 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
6309 #ifndef TOLUA_RELEASE
6310 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBackgroundColor'", NULL);
6311 #endif
6312 {
6313 const Color& tolua_ret = (const Color&) self->getBackgroundColor();
6314 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Color");
6315 }
6316 }
6317 return 1;
6318 #ifndef TOLUA_RELEASE
6319 tolua_lerror:
6320 tolua_error(tolua_S,"#ferror in function 'getBackgroundColor'.",&tolua_err);
6321 return 0;
6322 #endif
6323 }
6324 #endif //#ifndef TOLUA_DISABLE
6325
6326 /* method: setDisabledColor of class Widget */
6327 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setDisabledColor00
6328 static int tolua_stratagus_Widget_setDisabledColor00(lua_State* tolua_S)
6329 {
6330 #ifndef TOLUA_RELEASE
6331 tolua_Error tolua_err;
6332 if (
6333 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6334 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Color",0,&tolua_err)) ||
6335 !tolua_isnoobj(tolua_S,3,&tolua_err)
6336 )
6337 goto tolua_lerror;
6338 else
6339 #endif
6340 {
6341 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6342 const Color color = *((const Color*) tolua_tousertype(tolua_S,2,0));
6343 #ifndef TOLUA_RELEASE
6344 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDisabledColor'", NULL);
6345 #endif
6346 {
6347 self->setDisabledColor(color);
6348 }
6349 }
6350 return 0;
6351 #ifndef TOLUA_RELEASE
6352 tolua_lerror:
6353 tolua_error(tolua_S,"#ferror in function 'setDisabledColor'.",&tolua_err);
6354 return 0;
6355 #endif
6356 }
6357 #endif //#ifndef TOLUA_DISABLE
6358
6359 /* method: getDisabledColor of class Widget */
6360 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getDisabledColor00
6361 static int tolua_stratagus_Widget_getDisabledColor00(lua_State* tolua_S)
6362 {
6363 #ifndef TOLUA_RELEASE
6364 tolua_Error tolua_err;
6365 if (
6366 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
6367 !tolua_isnoobj(tolua_S,2,&tolua_err)
6368 )
6369 goto tolua_lerror;
6370 else
6371 #endif
6372 {
6373 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
6374 #ifndef TOLUA_RELEASE
6375 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDisabledColor'", NULL);
6376 #endif
6377 {
6378 const Color& tolua_ret = (const Color&) self->getDisabledColor();
6379 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Color");
6380 }
6381 }
6382 return 1;
6383 #ifndef TOLUA_RELEASE
6384 tolua_lerror:
6385 tolua_error(tolua_S,"#ferror in function 'getDisabledColor'.",&tolua_err);
6386 return 0;
6387 #endif
6388 }
6389 #endif //#ifndef TOLUA_DISABLE
6390
6391 /* method: setGlobalFont of class Widget */
6392 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setGlobalFont00
6393 static int tolua_stratagus_Widget_setGlobalFont00(lua_State* tolua_S)
6394 {
6395 #ifndef TOLUA_RELEASE
6396 tolua_Error tolua_err;
6397 if (
6398 !tolua_isusertable(tolua_S,1,"Widget",0,&tolua_err) ||
6399 !tolua_isusertype(tolua_S,2,"CFont",0,&tolua_err) ||
6400 !tolua_isnoobj(tolua_S,3,&tolua_err)
6401 )
6402 goto tolua_lerror;
6403 else
6404 #endif
6405 {
6406 CFont* font = ((CFont*) tolua_tousertype(tolua_S,2,0));
6407 {
6408 Widget::setGlobalFont(font);
6409 }
6410 }
6411 return 0;
6412 #ifndef TOLUA_RELEASE
6413 tolua_lerror:
6414 tolua_error(tolua_S,"#ferror in function 'setGlobalFont'.",&tolua_err);
6415 return 0;
6416 #endif
6417 }
6418 #endif //#ifndef TOLUA_DISABLE
6419
6420 /* method: setFont of class Widget */
6421 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setFont00
6422 static int tolua_stratagus_Widget_setFont00(lua_State* tolua_S)
6423 {
6424 #ifndef TOLUA_RELEASE
6425 tolua_Error tolua_err;
6426 if (
6427 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6428 !tolua_isusertype(tolua_S,2,"CFont",0,&tolua_err) ||
6429 !tolua_isnoobj(tolua_S,3,&tolua_err)
6430 )
6431 goto tolua_lerror;
6432 else
6433 #endif
6434 {
6435 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6436 CFont* font = ((CFont*) tolua_tousertype(tolua_S,2,0));
6437 #ifndef TOLUA_RELEASE
6438 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFont'", NULL);
6439 #endif
6440 {
6441 self->setFont(font);
6442 }
6443 }
6444 return 0;
6445 #ifndef TOLUA_RELEASE
6446 tolua_lerror:
6447 tolua_error(tolua_S,"#ferror in function 'setFont'.",&tolua_err);
6448 return 0;
6449 #endif
6450 }
6451 #endif //#ifndef TOLUA_DISABLE
6452
6453 /* method: getHotKey of class Widget */
6454 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_getHotKey00
6455 static int tolua_stratagus_Widget_getHotKey00(lua_State* tolua_S)
6456 {
6457 #ifndef TOLUA_RELEASE
6458 tolua_Error tolua_err;
6459 if (
6460 !tolua_isusertype(tolua_S,1,"const Widget",0,&tolua_err) ||
6461 !tolua_isnoobj(tolua_S,2,&tolua_err)
6462 )
6463 goto tolua_lerror;
6464 else
6465 #endif
6466 {
6467 const Widget* self = (const Widget*) tolua_tousertype(tolua_S,1,0);
6468 #ifndef TOLUA_RELEASE
6469 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHotKey'", NULL);
6470 #endif
6471 {
6472 int tolua_ret = (int) self->getHotKey();
6473 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6474 }
6475 }
6476 return 1;
6477 #ifndef TOLUA_RELEASE
6478 tolua_lerror:
6479 tolua_error(tolua_S,"#ferror in function 'getHotKey'.",&tolua_err);
6480 return 0;
6481 #endif
6482 }
6483 #endif //#ifndef TOLUA_DISABLE
6484
6485 /* method: setHotKey of class Widget */
6486 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setHotKey00
6487 static int tolua_stratagus_Widget_setHotKey00(lua_State* tolua_S)
6488 {
6489 #ifndef TOLUA_RELEASE
6490 tolua_Error tolua_err;
6491 if (
6492 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6493 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6494 !tolua_isnoobj(tolua_S,3,&tolua_err)
6495 )
6496 goto tolua_lerror;
6497 else
6498 #endif
6499 {
6500 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6501 const int key = ((const int) tolua_tonumber(tolua_S,2,0));
6502 #ifndef TOLUA_RELEASE
6503 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHotKey'", NULL);
6504 #endif
6505 {
6506 self->setHotKey(key);
6507 }
6508 }
6509 return 0;
6510 #ifndef TOLUA_RELEASE
6511 tolua_lerror:
6512 tolua_error(tolua_S,"#ferror in function 'setHotKey'.",&tolua_err);
6513 return 0;
6514 #endif
6515 }
6516 #endif //#ifndef TOLUA_DISABLE
6517
6518 /* method: setHotKey of class Widget */
6519 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_setHotKey01
6520 static int tolua_stratagus_Widget_setHotKey01(lua_State* tolua_S)
6521 {
6522 tolua_Error tolua_err;
6523 if (
6524 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6525 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
6526 !tolua_isnoobj(tolua_S,3,&tolua_err)
6527 )
6528 goto tolua_lerror;
6529 else
6530 {
6531 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6532 const char* key = ((const char*) tolua_tostring(tolua_S,2,0));
6533 #ifndef TOLUA_RELEASE
6534 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHotKey'", NULL);
6535 #endif
6536 {
6537 self->setHotKey(key);
6538 }
6539 }
6540 return 0;
6541 tolua_lerror:
6542 return tolua_stratagus_Widget_setHotKey00(tolua_S);
6543 }
6544 #endif //#ifndef TOLUA_DISABLE
6545
6546 /* method: addActionListener of class Widget */
6547 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_addActionListener00
6548 static int tolua_stratagus_Widget_addActionListener00(lua_State* tolua_S)
6549 {
6550 #ifndef TOLUA_RELEASE
6551 tolua_Error tolua_err;
6552 if (
6553 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6554 !tolua_isusertype(tolua_S,2,"LuaActionListener",0,&tolua_err) ||
6555 !tolua_isnoobj(tolua_S,3,&tolua_err)
6556 )
6557 goto tolua_lerror;
6558 else
6559 #endif
6560 {
6561 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6562 LuaActionListener* actionListener = ((LuaActionListener*) tolua_tousertype(tolua_S,2,0));
6563 #ifndef TOLUA_RELEASE
6564 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addActionListener'", NULL);
6565 #endif
6566 {
6567 self->addActionListener(actionListener);
6568 }
6569 }
6570 return 0;
6571 #ifndef TOLUA_RELEASE
6572 tolua_lerror:
6573 tolua_error(tolua_S,"#ferror in function 'addActionListener'.",&tolua_err);
6574 return 0;
6575 #endif
6576 }
6577 #endif //#ifndef TOLUA_DISABLE
6578
6579 /* method: requestFocus of class Widget */
6580 #ifndef TOLUA_DISABLE_tolua_stratagus_Widget_requestFocus00
6581 static int tolua_stratagus_Widget_requestFocus00(lua_State* tolua_S)
6582 {
6583 #ifndef TOLUA_RELEASE
6584 tolua_Error tolua_err;
6585 if (
6586 !tolua_isusertype(tolua_S,1,"Widget",0,&tolua_err) ||
6587 !tolua_isnoobj(tolua_S,2,&tolua_err)
6588 )
6589 goto tolua_lerror;
6590 else
6591 #endif
6592 {
6593 Widget* self = (Widget*) tolua_tousertype(tolua_S,1,0);
6594 #ifndef TOLUA_RELEASE
6595 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'requestFocus'", NULL);
6596 #endif
6597 {
6598 self->requestFocus();
6599 }
6600 }
6601 return 0;
6602 #ifndef TOLUA_RELEASE
6603 tolua_lerror:
6604 tolua_error(tolua_S,"#ferror in function 'requestFocus'.",&tolua_err);
6605 return 0;
6606 #endif
6607 }
6608 #endif //#ifndef TOLUA_DISABLE
6609
6610 /* method: new of class ScrollArea */
6611 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollArea_new00
6612 static int tolua_stratagus_ScrollArea_new00(lua_State* tolua_S)
6613 {
6614 #ifndef TOLUA_RELEASE
6615 tolua_Error tolua_err;
6616 if (
6617 !tolua_isusertable(tolua_S,1,"ScrollArea",0,&tolua_err) ||
6618 !tolua_isnoobj(tolua_S,2,&tolua_err)
6619 )
6620 goto tolua_lerror;
6621 else
6622 #endif
6623 {
6624 {
6625 ScrollArea* tolua_ret = (ScrollArea*) Mtolua_new((ScrollArea)());
6626 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ScrollArea");
6627 }
6628 }
6629 return 1;
6630 #ifndef TOLUA_RELEASE
6631 tolua_lerror:
6632 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6633 return 0;
6634 #endif
6635 }
6636 #endif //#ifndef TOLUA_DISABLE
6637
6638 /* method: new_local of class ScrollArea */
6639 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollArea_new00_local
6640 static int tolua_stratagus_ScrollArea_new00_local(lua_State* tolua_S)
6641 {
6642 #ifndef TOLUA_RELEASE
6643 tolua_Error tolua_err;
6644 if (
6645 !tolua_isusertable(tolua_S,1,"ScrollArea",0,&tolua_err) ||
6646 !tolua_isnoobj(tolua_S,2,&tolua_err)
6647 )
6648 goto tolua_lerror;
6649 else
6650 #endif
6651 {
6652 {
6653 ScrollArea* tolua_ret = (ScrollArea*) Mtolua_new((ScrollArea)());
6654 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ScrollArea");
6655 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6656 }
6657 }
6658 return 1;
6659 #ifndef TOLUA_RELEASE
6660 tolua_lerror:
6661 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6662 return 0;
6663 #endif
6664 }
6665 #endif //#ifndef TOLUA_DISABLE
6666
6667 /* method: setContent of class ScrollArea */
6668 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollArea_setContent00
6669 static int tolua_stratagus_ScrollArea_setContent00(lua_State* tolua_S)
6670 {
6671 #ifndef TOLUA_RELEASE
6672 tolua_Error tolua_err;
6673 if (
6674 !tolua_isusertype(tolua_S,1,"ScrollArea",0,&tolua_err) ||
6675 !tolua_isusertype(tolua_S,2,"Widget",0,&tolua_err) ||
6676 !tolua_isnoobj(tolua_S,3,&tolua_err)
6677 )
6678 goto tolua_lerror;
6679 else
6680 #endif
6681 {
6682 ScrollArea* self = (ScrollArea*) tolua_tousertype(tolua_S,1,0);
6683 Widget* widget = ((Widget*) tolua_tousertype(tolua_S,2,0));
6684 #ifndef TOLUA_RELEASE
6685 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setContent'", NULL);
6686 #endif
6687 {
6688 self->setContent(widget);
6689 }
6690 }
6691 return 0;
6692 #ifndef TOLUA_RELEASE
6693 tolua_lerror:
6694 tolua_error(tolua_S,"#ferror in function 'setContent'.",&tolua_err);
6695 return 0;
6696 #endif
6697 }
6698 #endif //#ifndef TOLUA_DISABLE
6699
6700 /* method: getContent of class ScrollArea */
6701 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollArea_getContent00
6702 static int tolua_stratagus_ScrollArea_getContent00(lua_State* tolua_S)
6703 {
6704 #ifndef TOLUA_RELEASE
6705 tolua_Error tolua_err;
6706 if (
6707 !tolua_isusertype(tolua_S,1,"ScrollArea",0,&tolua_err) ||
6708 !tolua_isnoobj(tolua_S,2,&tolua_err)
6709 )
6710 goto tolua_lerror;
6711 else
6712 #endif
6713 {
6714 ScrollArea* self = (ScrollArea*) tolua_tousertype(tolua_S,1,0);
6715 #ifndef TOLUA_RELEASE
6716 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getContent'", NULL);
6717 #endif
6718 {
6719 Widget* tolua_ret = (Widget*) self->getContent();
6720 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Widget");
6721 }
6722 }
6723 return 1;
6724 #ifndef TOLUA_RELEASE
6725 tolua_lerror:
6726 tolua_error(tolua_S,"#ferror in function 'getContent'.",&tolua_err);
6727 return 0;
6728 #endif
6729 }
6730 #endif //#ifndef TOLUA_DISABLE
6731
6732 /* method: setScrollbarWidth of class ScrollArea */
6733 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollArea_setScrollbarWidth00
6734 static int tolua_stratagus_ScrollArea_setScrollbarWidth00(lua_State* tolua_S)
6735 {
6736 #ifndef TOLUA_RELEASE
6737 tolua_Error tolua_err;
6738 if (
6739 !tolua_isusertype(tolua_S,1,"ScrollArea",0,&tolua_err) ||
6740 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6741 !tolua_isnoobj(tolua_S,3,&tolua_err)
6742 )
6743 goto tolua_lerror;
6744 else
6745 #endif
6746 {
6747 ScrollArea* self = (ScrollArea*) tolua_tousertype(tolua_S,1,0);
6748 int width = ((int) tolua_tonumber(tolua_S,2,0));
6749 #ifndef TOLUA_RELEASE
6750 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setScrollbarWidth'", NULL);
6751 #endif
6752 {
6753 self->setScrollbarWidth(width);
6754 }
6755 }
6756 return 0;
6757 #ifndef TOLUA_RELEASE
6758 tolua_lerror:
6759 tolua_error(tolua_S,"#ferror in function 'setScrollbarWidth'.",&tolua_err);
6760 return 0;
6761 #endif
6762 }
6763 #endif //#ifndef TOLUA_DISABLE
6764
6765 /* method: getScrollbarWidth of class ScrollArea */
6766 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollArea_getScrollbarWidth00
6767 static int tolua_stratagus_ScrollArea_getScrollbarWidth00(lua_State* tolua_S)
6768 {
6769 #ifndef TOLUA_RELEASE
6770 tolua_Error tolua_err;
6771 if (
6772 !tolua_isusertype(tolua_S,1,"ScrollArea",0,&tolua_err) ||
6773 !tolua_isnoobj(tolua_S,2,&tolua_err)
6774 )
6775 goto tolua_lerror;
6776 else
6777 #endif
6778 {
6779 ScrollArea* self = (ScrollArea*) tolua_tousertype(tolua_S,1,0);
6780 #ifndef TOLUA_RELEASE
6781 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScrollbarWidth'", NULL);
6782 #endif
6783 {
6784 int tolua_ret = (int) self->getScrollbarWidth();
6785 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6786 }
6787 }
6788 return 1;
6789 #ifndef TOLUA_RELEASE
6790 tolua_lerror:
6791 tolua_error(tolua_S,"#ferror in function 'getScrollbarWidth'.",&tolua_err);
6792 return 0;
6793 #endif
6794 }
6795 #endif //#ifndef TOLUA_DISABLE
6796
6797 /* method: new of class ImageWidget */
6798 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageWidget_new00
6799 static int tolua_stratagus_ImageWidget_new00(lua_State* tolua_S)
6800 {
6801 #ifndef TOLUA_RELEASE
6802 tolua_Error tolua_err;
6803 if (
6804 !tolua_isusertable(tolua_S,1,"ImageWidget",0,&tolua_err) ||
6805 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
6806 !tolua_isnoobj(tolua_S,3,&tolua_err)
6807 )
6808 goto tolua_lerror;
6809 else
6810 #endif
6811 {
6812 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
6813 {
6814 ImageWidget* tolua_ret = (ImageWidget*) Mtolua_new((ImageWidget)(image));
6815 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageWidget");
6816 }
6817 }
6818 return 1;
6819 #ifndef TOLUA_RELEASE
6820 tolua_lerror:
6821 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6822 return 0;
6823 #endif
6824 }
6825 #endif //#ifndef TOLUA_DISABLE
6826
6827 /* method: new_local of class ImageWidget */
6828 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageWidget_new00_local
6829 static int tolua_stratagus_ImageWidget_new00_local(lua_State* tolua_S)
6830 {
6831 #ifndef TOLUA_RELEASE
6832 tolua_Error tolua_err;
6833 if (
6834 !tolua_isusertable(tolua_S,1,"ImageWidget",0,&tolua_err) ||
6835 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
6836 !tolua_isnoobj(tolua_S,3,&tolua_err)
6837 )
6838 goto tolua_lerror;
6839 else
6840 #endif
6841 {
6842 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
6843 {
6844 ImageWidget* tolua_ret = (ImageWidget*) Mtolua_new((ImageWidget)(image));
6845 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageWidget");
6846 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6847 }
6848 }
6849 return 1;
6850 #ifndef TOLUA_RELEASE
6851 tolua_lerror:
6852 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6853 return 0;
6854 #endif
6855 }
6856 #endif //#ifndef TOLUA_DISABLE
6857
6858 /* method: new of class ButtonWidget */
6859 #ifndef TOLUA_DISABLE_tolua_stratagus_ButtonWidget_new00
6860 static int tolua_stratagus_ButtonWidget_new00(lua_State* tolua_S)
6861 {
6862 #ifndef TOLUA_RELEASE
6863 tolua_Error tolua_err;
6864 if (
6865 !tolua_isusertable(tolua_S,1,"ButtonWidget",0,&tolua_err) ||
6866 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6867 !tolua_isnoobj(tolua_S,3,&tolua_err)
6868 )
6869 goto tolua_lerror;
6870 else
6871 #endif
6872 {
6873 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6874 {
6875 ButtonWidget* tolua_ret = (ButtonWidget*) Mtolua_new((ButtonWidget)(caption));
6876 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ButtonWidget");
6877 }
6878 }
6879 return 1;
6880 #ifndef TOLUA_RELEASE
6881 tolua_lerror:
6882 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6883 return 0;
6884 #endif
6885 }
6886 #endif //#ifndef TOLUA_DISABLE
6887
6888 /* method: new_local of class ButtonWidget */
6889 #ifndef TOLUA_DISABLE_tolua_stratagus_ButtonWidget_new00_local
6890 static int tolua_stratagus_ButtonWidget_new00_local(lua_State* tolua_S)
6891 {
6892 #ifndef TOLUA_RELEASE
6893 tolua_Error tolua_err;
6894 if (
6895 !tolua_isusertable(tolua_S,1,"ButtonWidget",0,&tolua_err) ||
6896 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6897 !tolua_isnoobj(tolua_S,3,&tolua_err)
6898 )
6899 goto tolua_lerror;
6900 else
6901 #endif
6902 {
6903 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6904 {
6905 ButtonWidget* tolua_ret = (ButtonWidget*) Mtolua_new((ButtonWidget)(caption));
6906 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ButtonWidget");
6907 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6908 }
6909 }
6910 return 1;
6911 #ifndef TOLUA_RELEASE
6912 tolua_lerror:
6913 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6914 return 0;
6915 #endif
6916 }
6917 #endif //#ifndef TOLUA_DISABLE
6918
6919 /* method: setCaption of class ButtonWidget */
6920 #ifndef TOLUA_DISABLE_tolua_stratagus_ButtonWidget_setCaption00
6921 static int tolua_stratagus_ButtonWidget_setCaption00(lua_State* tolua_S)
6922 {
6923 #ifndef TOLUA_RELEASE
6924 tolua_Error tolua_err;
6925 if (
6926 !tolua_isusertype(tolua_S,1,"ButtonWidget",0,&tolua_err) ||
6927 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6928 !tolua_isnoobj(tolua_S,3,&tolua_err)
6929 )
6930 goto tolua_lerror;
6931 else
6932 #endif
6933 {
6934 ButtonWidget* self = (ButtonWidget*) tolua_tousertype(tolua_S,1,0);
6935 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6936 #ifndef TOLUA_RELEASE
6937 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaption'", NULL);
6938 #endif
6939 {
6940 self->setCaption(caption);
6941 }
6942 }
6943 return 0;
6944 #ifndef TOLUA_RELEASE
6945 tolua_lerror:
6946 tolua_error(tolua_S,"#ferror in function 'setCaption'.",&tolua_err);
6947 return 0;
6948 #endif
6949 }
6950 #endif //#ifndef TOLUA_DISABLE
6951
6952 /* method: getCaption of class ButtonWidget */
6953 #ifndef TOLUA_DISABLE_tolua_stratagus_ButtonWidget_getCaption00
6954 static int tolua_stratagus_ButtonWidget_getCaption00(lua_State* tolua_S)
6955 {
6956 #ifndef TOLUA_RELEASE
6957 tolua_Error tolua_err;
6958 if (
6959 !tolua_isusertype(tolua_S,1,"const ButtonWidget",0,&tolua_err) ||
6960 !tolua_isnoobj(tolua_S,2,&tolua_err)
6961 )
6962 goto tolua_lerror;
6963 else
6964 #endif
6965 {
6966 const ButtonWidget* self = (const ButtonWidget*) tolua_tousertype(tolua_S,1,0);
6967 #ifndef TOLUA_RELEASE
6968 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaption'", NULL);
6969 #endif
6970 {
6971 const std::string tolua_ret = (const std::string) self->getCaption();
6972 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
6973 }
6974 }
6975 return 1;
6976 #ifndef TOLUA_RELEASE
6977 tolua_lerror:
6978 tolua_error(tolua_S,"#ferror in function 'getCaption'.",&tolua_err);
6979 return 0;
6980 #endif
6981 }
6982 #endif //#ifndef TOLUA_DISABLE
6983
6984 /* method: adjustSize of class ButtonWidget */
6985 #ifndef TOLUA_DISABLE_tolua_stratagus_ButtonWidget_adjustSize00
6986 static int tolua_stratagus_ButtonWidget_adjustSize00(lua_State* tolua_S)
6987 {
6988 #ifndef TOLUA_RELEASE
6989 tolua_Error tolua_err;
6990 if (
6991 !tolua_isusertype(tolua_S,1,"ButtonWidget",0,&tolua_err) ||
6992 !tolua_isnoobj(tolua_S,2,&tolua_err)
6993 )
6994 goto tolua_lerror;
6995 else
6996 #endif
6997 {
6998 ButtonWidget* self = (ButtonWidget*) tolua_tousertype(tolua_S,1,0);
6999 #ifndef TOLUA_RELEASE
7000 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'adjustSize'", NULL);
7001 #endif
7002 {
7003 self->adjustSize();
7004 }
7005 }
7006 return 0;
7007 #ifndef TOLUA_RELEASE
7008 tolua_lerror:
7009 tolua_error(tolua_S,"#ferror in function 'adjustSize'.",&tolua_err);
7010 return 0;
7011 #endif
7012 }
7013 #endif //#ifndef TOLUA_DISABLE
7014
7015 /* method: new of class ImageButton */
7016 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageButton_new00
7017 static int tolua_stratagus_ImageButton_new00(lua_State* tolua_S)
7018 {
7019 #ifndef TOLUA_RELEASE
7020 tolua_Error tolua_err;
7021 if (
7022 !tolua_isusertable(tolua_S,1,"ImageButton",0,&tolua_err) ||
7023 !tolua_isnoobj(tolua_S,2,&tolua_err)
7024 )
7025 goto tolua_lerror;
7026 else
7027 #endif
7028 {
7029 {
7030 ImageButton* tolua_ret = (ImageButton*) Mtolua_new((ImageButton)());
7031 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageButton");
7032 }
7033 }
7034 return 1;
7035 #ifndef TOLUA_RELEASE
7036 tolua_lerror:
7037 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7038 return 0;
7039 #endif
7040 }
7041 #endif //#ifndef TOLUA_DISABLE
7042
7043 /* method: new_local of class ImageButton */
7044 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageButton_new00_local
7045 static int tolua_stratagus_ImageButton_new00_local(lua_State* tolua_S)
7046 {
7047 #ifndef TOLUA_RELEASE
7048 tolua_Error tolua_err;
7049 if (
7050 !tolua_isusertable(tolua_S,1,"ImageButton",0,&tolua_err) ||
7051 !tolua_isnoobj(tolua_S,2,&tolua_err)
7052 )
7053 goto tolua_lerror;
7054 else
7055 #endif
7056 {
7057 {
7058 ImageButton* tolua_ret = (ImageButton*) Mtolua_new((ImageButton)());
7059 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageButton");
7060 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7061 }
7062 }
7063 return 1;
7064 #ifndef TOLUA_RELEASE
7065 tolua_lerror:
7066 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7067 return 0;
7068 #endif
7069 }
7070 #endif //#ifndef TOLUA_DISABLE
7071
7072 /* method: new of class ImageButton */
7073 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageButton_new01
7074 static int tolua_stratagus_ImageButton_new01(lua_State* tolua_S)
7075 {
7076 tolua_Error tolua_err;
7077 if (
7078 !tolua_isusertable(tolua_S,1,"ImageButton",0,&tolua_err) ||
7079 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7080 !tolua_isnoobj(tolua_S,3,&tolua_err)
7081 )
7082 goto tolua_lerror;
7083 else
7084 {
7085 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7086 {
7087 ImageButton* tolua_ret = (ImageButton*) Mtolua_new((ImageButton)(caption));
7088 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageButton");
7089 }
7090 }
7091 return 1;
7092 tolua_lerror:
7093 return tolua_stratagus_ImageButton_new00(tolua_S);
7094 }
7095 #endif //#ifndef TOLUA_DISABLE
7096
7097 /* method: new_local of class ImageButton */
7098 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageButton_new01_local
7099 static int tolua_stratagus_ImageButton_new01_local(lua_State* tolua_S)
7100 {
7101 tolua_Error tolua_err;
7102 if (
7103 !tolua_isusertable(tolua_S,1,"ImageButton",0,&tolua_err) ||
7104 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7105 !tolua_isnoobj(tolua_S,3,&tolua_err)
7106 )
7107 goto tolua_lerror;
7108 else
7109 {
7110 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7111 {
7112 ImageButton* tolua_ret = (ImageButton*) Mtolua_new((ImageButton)(caption));
7113 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageButton");
7114 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7115 }
7116 }
7117 return 1;
7118 tolua_lerror:
7119 return tolua_stratagus_ImageButton_new00_local(tolua_S);
7120 }
7121 #endif //#ifndef TOLUA_DISABLE
7122
7123 /* method: setNormalImage of class ImageButton */
7124 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageButton_setNormalImage00
7125 static int tolua_stratagus_ImageButton_setNormalImage00(lua_State* tolua_S)
7126 {
7127 #ifndef TOLUA_RELEASE
7128 tolua_Error tolua_err;
7129 if (
7130 !tolua_isusertype(tolua_S,1,"ImageButton",0,&tolua_err) ||
7131 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
7132 !tolua_isnoobj(tolua_S,3,&tolua_err)
7133 )
7134 goto tolua_lerror;
7135 else
7136 #endif
7137 {
7138 ImageButton* self = (ImageButton*) tolua_tousertype(tolua_S,1,0);
7139 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
7140 #ifndef TOLUA_RELEASE
7141 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNormalImage'", NULL);
7142 #endif
7143 {
7144 self->setNormalImage(image);
7145 }
7146 }
7147 return 0;
7148 #ifndef TOLUA_RELEASE
7149 tolua_lerror:
7150 tolua_error(tolua_S,"#ferror in function 'setNormalImage'.",&tolua_err);
7151 return 0;
7152 #endif
7153 }
7154 #endif //#ifndef TOLUA_DISABLE
7155
7156 /* method: setPressedImage of class ImageButton */
7157 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageButton_setPressedImage00
7158 static int tolua_stratagus_ImageButton_setPressedImage00(lua_State* tolua_S)
7159 {
7160 #ifndef TOLUA_RELEASE
7161 tolua_Error tolua_err;
7162 if (
7163 !tolua_isusertype(tolua_S,1,"ImageButton",0,&tolua_err) ||
7164 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
7165 !tolua_isnoobj(tolua_S,3,&tolua_err)
7166 )
7167 goto tolua_lerror;
7168 else
7169 #endif
7170 {
7171 ImageButton* self = (ImageButton*) tolua_tousertype(tolua_S,1,0);
7172 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
7173 #ifndef TOLUA_RELEASE
7174 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPressedImage'", NULL);
7175 #endif
7176 {
7177 self->setPressedImage(image);
7178 }
7179 }
7180 return 0;
7181 #ifndef TOLUA_RELEASE
7182 tolua_lerror:
7183 tolua_error(tolua_S,"#ferror in function 'setPressedImage'.",&tolua_err);
7184 return 0;
7185 #endif
7186 }
7187 #endif //#ifndef TOLUA_DISABLE
7188
7189 /* method: setDisabledImage of class ImageButton */
7190 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageButton_setDisabledImage00
7191 static int tolua_stratagus_ImageButton_setDisabledImage00(lua_State* tolua_S)
7192 {
7193 #ifndef TOLUA_RELEASE
7194 tolua_Error tolua_err;
7195 if (
7196 !tolua_isusertype(tolua_S,1,"ImageButton",0,&tolua_err) ||
7197 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
7198 !tolua_isnoobj(tolua_S,3,&tolua_err)
7199 )
7200 goto tolua_lerror;
7201 else
7202 #endif
7203 {
7204 ImageButton* self = (ImageButton*) tolua_tousertype(tolua_S,1,0);
7205 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
7206 #ifndef TOLUA_RELEASE
7207 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDisabledImage'", NULL);
7208 #endif
7209 {
7210 self->setDisabledImage(image);
7211 }
7212 }
7213 return 0;
7214 #ifndef TOLUA_RELEASE
7215 tolua_lerror:
7216 tolua_error(tolua_S,"#ferror in function 'setDisabledImage'.",&tolua_err);
7217 return 0;
7218 #endif
7219 }
7220 #endif //#ifndef TOLUA_DISABLE
7221
7222 /* method: new of class RadioButton */
7223 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_new00
7224 static int tolua_stratagus_RadioButton_new00(lua_State* tolua_S)
7225 {
7226 #ifndef TOLUA_RELEASE
7227 tolua_Error tolua_err;
7228 if (
7229 !tolua_isusertable(tolua_S,1,"RadioButton",0,&tolua_err) ||
7230 !tolua_isnoobj(tolua_S,2,&tolua_err)
7231 )
7232 goto tolua_lerror;
7233 else
7234 #endif
7235 {
7236 {
7237 RadioButton* tolua_ret = (RadioButton*) Mtolua_new((RadioButton)());
7238 tolua_pushusertype(tolua_S,(void*)tolua_ret,"RadioButton");
7239 }
7240 }
7241 return 1;
7242 #ifndef TOLUA_RELEASE
7243 tolua_lerror:
7244 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7245 return 0;
7246 #endif
7247 }
7248 #endif //#ifndef TOLUA_DISABLE
7249
7250 /* method: new_local of class RadioButton */
7251 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_new00_local
7252 static int tolua_stratagus_RadioButton_new00_local(lua_State* tolua_S)
7253 {
7254 #ifndef TOLUA_RELEASE
7255 tolua_Error tolua_err;
7256 if (
7257 !tolua_isusertable(tolua_S,1,"RadioButton",0,&tolua_err) ||
7258 !tolua_isnoobj(tolua_S,2,&tolua_err)
7259 )
7260 goto tolua_lerror;
7261 else
7262 #endif
7263 {
7264 {
7265 RadioButton* tolua_ret = (RadioButton*) Mtolua_new((RadioButton)());
7266 tolua_pushusertype(tolua_S,(void*)tolua_ret,"RadioButton");
7267 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7268 }
7269 }
7270 return 1;
7271 #ifndef TOLUA_RELEASE
7272 tolua_lerror:
7273 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7274 return 0;
7275 #endif
7276 }
7277 #endif //#ifndef TOLUA_DISABLE
7278
7279 /* method: new of class RadioButton */
7280 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_new01
7281 static int tolua_stratagus_RadioButton_new01(lua_State* tolua_S)
7282 {
7283 tolua_Error tolua_err;
7284 if (
7285 !tolua_isusertable(tolua_S,1,"RadioButton",0,&tolua_err) ||
7286 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7287 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
7288 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
7289 !tolua_isnoobj(tolua_S,5,&tolua_err)
7290 )
7291 goto tolua_lerror;
7292 else
7293 {
7294 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7295 const std::string group = ((const std::string) tolua_tocppstring(tolua_S,3,0));
7296 bool marked = ((bool) tolua_toboolean(tolua_S,4,false));
7297 {
7298 RadioButton* tolua_ret = (RadioButton*) Mtolua_new((RadioButton)(caption,group,marked));
7299 tolua_pushusertype(tolua_S,(void*)tolua_ret,"RadioButton");
7300 }
7301 }
7302 return 1;
7303 tolua_lerror:
7304 return tolua_stratagus_RadioButton_new00(tolua_S);
7305 }
7306 #endif //#ifndef TOLUA_DISABLE
7307
7308 /* method: new_local of class RadioButton */
7309 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_new01_local
7310 static int tolua_stratagus_RadioButton_new01_local(lua_State* tolua_S)
7311 {
7312 tolua_Error tolua_err;
7313 if (
7314 !tolua_isusertable(tolua_S,1,"RadioButton",0,&tolua_err) ||
7315 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7316 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
7317 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
7318 !tolua_isnoobj(tolua_S,5,&tolua_err)
7319 )
7320 goto tolua_lerror;
7321 else
7322 {
7323 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7324 const std::string group = ((const std::string) tolua_tocppstring(tolua_S,3,0));
7325 bool marked = ((bool) tolua_toboolean(tolua_S,4,false));
7326 {
7327 RadioButton* tolua_ret = (RadioButton*) Mtolua_new((RadioButton)(caption,group,marked));
7328 tolua_pushusertype(tolua_S,(void*)tolua_ret,"RadioButton");
7329 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7330 }
7331 }
7332 return 1;
7333 tolua_lerror:
7334 return tolua_stratagus_RadioButton_new00_local(tolua_S);
7335 }
7336 #endif //#ifndef TOLUA_DISABLE
7337
7338 /* method: isMarked of class RadioButton */
7339 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_isMarked00
7340 static int tolua_stratagus_RadioButton_isMarked00(lua_State* tolua_S)
7341 {
7342 #ifndef TOLUA_RELEASE
7343 tolua_Error tolua_err;
7344 if (
7345 !tolua_isusertype(tolua_S,1,"RadioButton",0,&tolua_err) ||
7346 !tolua_isnoobj(tolua_S,2,&tolua_err)
7347 )
7348 goto tolua_lerror;
7349 else
7350 #endif
7351 {
7352 RadioButton* self = (RadioButton*) tolua_tousertype(tolua_S,1,0);
7353 #ifndef TOLUA_RELEASE
7354 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isMarked'", NULL);
7355 #endif
7356 {
7357 bool tolua_ret = (bool) self->isMarked();
7358 tolua_pushboolean(tolua_S,(bool)tolua_ret);
7359 }
7360 }
7361 return 1;
7362 #ifndef TOLUA_RELEASE
7363 tolua_lerror:
7364 tolua_error(tolua_S,"#ferror in function 'isMarked'.",&tolua_err);
7365 return 0;
7366 #endif
7367 }
7368 #endif //#ifndef TOLUA_DISABLE
7369
7370 /* method: setMarked of class RadioButton */
7371 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_setMarked00
7372 static int tolua_stratagus_RadioButton_setMarked00(lua_State* tolua_S)
7373 {
7374 #ifndef TOLUA_RELEASE
7375 tolua_Error tolua_err;
7376 if (
7377 !tolua_isusertype(tolua_S,1,"RadioButton",0,&tolua_err) ||
7378 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
7379 !tolua_isnoobj(tolua_S,3,&tolua_err)
7380 )
7381 goto tolua_lerror;
7382 else
7383 #endif
7384 {
7385 RadioButton* self = (RadioButton*) tolua_tousertype(tolua_S,1,0);
7386 bool marked = ((bool) tolua_toboolean(tolua_S,2,0));
7387 #ifndef TOLUA_RELEASE
7388 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMarked'", NULL);
7389 #endif
7390 {
7391 self->setMarked(marked);
7392 }
7393 }
7394 return 0;
7395 #ifndef TOLUA_RELEASE
7396 tolua_lerror:
7397 tolua_error(tolua_S,"#ferror in function 'setMarked'.",&tolua_err);
7398 return 0;
7399 #endif
7400 }
7401 #endif //#ifndef TOLUA_DISABLE
7402
7403 /* method: getCaption of class RadioButton */
7404 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_getCaption00
7405 static int tolua_stratagus_RadioButton_getCaption00(lua_State* tolua_S)
7406 {
7407 #ifndef TOLUA_RELEASE
7408 tolua_Error tolua_err;
7409 if (
7410 !tolua_isusertype(tolua_S,1,"const RadioButton",0,&tolua_err) ||
7411 !tolua_isnoobj(tolua_S,2,&tolua_err)
7412 )
7413 goto tolua_lerror;
7414 else
7415 #endif
7416 {
7417 const RadioButton* self = (const RadioButton*) tolua_tousertype(tolua_S,1,0);
7418 #ifndef TOLUA_RELEASE
7419 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaption'", NULL);
7420 #endif
7421 {
7422 const std::string tolua_ret = (const std::string) self->getCaption();
7423 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
7424 }
7425 }
7426 return 1;
7427 #ifndef TOLUA_RELEASE
7428 tolua_lerror:
7429 tolua_error(tolua_S,"#ferror in function 'getCaption'.",&tolua_err);
7430 return 0;
7431 #endif
7432 }
7433 #endif //#ifndef TOLUA_DISABLE
7434
7435 /* method: setCaption of class RadioButton */
7436 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_setCaption00
7437 static int tolua_stratagus_RadioButton_setCaption00(lua_State* tolua_S)
7438 {
7439 #ifndef TOLUA_RELEASE
7440 tolua_Error tolua_err;
7441 if (
7442 !tolua_isusertype(tolua_S,1,"RadioButton",0,&tolua_err) ||
7443 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7444 !tolua_isnoobj(tolua_S,3,&tolua_err)
7445 )
7446 goto tolua_lerror;
7447 else
7448 #endif
7449 {
7450 RadioButton* self = (RadioButton*) tolua_tousertype(tolua_S,1,0);
7451 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7452 #ifndef TOLUA_RELEASE
7453 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaption'", NULL);
7454 #endif
7455 {
7456 self->setCaption(caption);
7457 }
7458 }
7459 return 0;
7460 #ifndef TOLUA_RELEASE
7461 tolua_lerror:
7462 tolua_error(tolua_S,"#ferror in function 'setCaption'.",&tolua_err);
7463 return 0;
7464 #endif
7465 }
7466 #endif //#ifndef TOLUA_DISABLE
7467
7468 /* method: setGroup of class RadioButton */
7469 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_setGroup00
7470 static int tolua_stratagus_RadioButton_setGroup00(lua_State* tolua_S)
7471 {
7472 #ifndef TOLUA_RELEASE
7473 tolua_Error tolua_err;
7474 if (
7475 !tolua_isusertype(tolua_S,1,"RadioButton",0,&tolua_err) ||
7476 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7477 !tolua_isnoobj(tolua_S,3,&tolua_err)
7478 )
7479 goto tolua_lerror;
7480 else
7481 #endif
7482 {
7483 RadioButton* self = (RadioButton*) tolua_tousertype(tolua_S,1,0);
7484 const std::string group = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7485 #ifndef TOLUA_RELEASE
7486 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setGroup'", NULL);
7487 #endif
7488 {
7489 self->setGroup(group);
7490 }
7491 }
7492 return 0;
7493 #ifndef TOLUA_RELEASE
7494 tolua_lerror:
7495 tolua_error(tolua_S,"#ferror in function 'setGroup'.",&tolua_err);
7496 return 0;
7497 #endif
7498 }
7499 #endif //#ifndef TOLUA_DISABLE
7500
7501 /* method: getGroup of class RadioButton */
7502 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_getGroup00
7503 static int tolua_stratagus_RadioButton_getGroup00(lua_State* tolua_S)
7504 {
7505 #ifndef TOLUA_RELEASE
7506 tolua_Error tolua_err;
7507 if (
7508 !tolua_isusertype(tolua_S,1,"const RadioButton",0,&tolua_err) ||
7509 !tolua_isnoobj(tolua_S,2,&tolua_err)
7510 )
7511 goto tolua_lerror;
7512 else
7513 #endif
7514 {
7515 const RadioButton* self = (const RadioButton*) tolua_tousertype(tolua_S,1,0);
7516 #ifndef TOLUA_RELEASE
7517 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getGroup'", NULL);
7518 #endif
7519 {
7520 const std::string tolua_ret = (const std::string) self->getGroup();
7521 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
7522 }
7523 }
7524 return 1;
7525 #ifndef TOLUA_RELEASE
7526 tolua_lerror:
7527 tolua_error(tolua_S,"#ferror in function 'getGroup'.",&tolua_err);
7528 return 0;
7529 #endif
7530 }
7531 #endif //#ifndef TOLUA_DISABLE
7532
7533 /* method: adjustSize of class RadioButton */
7534 #ifndef TOLUA_DISABLE_tolua_stratagus_RadioButton_adjustSize00
7535 static int tolua_stratagus_RadioButton_adjustSize00(lua_State* tolua_S)
7536 {
7537 #ifndef TOLUA_RELEASE
7538 tolua_Error tolua_err;
7539 if (
7540 !tolua_isusertype(tolua_S,1,"RadioButton",0,&tolua_err) ||
7541 !tolua_isnoobj(tolua_S,2,&tolua_err)
7542 )
7543 goto tolua_lerror;
7544 else
7545 #endif
7546 {
7547 RadioButton* self = (RadioButton*) tolua_tousertype(tolua_S,1,0);
7548 #ifndef TOLUA_RELEASE
7549 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'adjustSize'", NULL);
7550 #endif
7551 {
7552 self->adjustSize();
7553 }
7554 }
7555 return 0;
7556 #ifndef TOLUA_RELEASE
7557 tolua_lerror:
7558 tolua_error(tolua_S,"#ferror in function 'adjustSize'.",&tolua_err);
7559 return 0;
7560 #endif
7561 }
7562 #endif //#ifndef TOLUA_DISABLE
7563
7564 /* method: new of class ImageRadioButton */
7565 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageRadioButton_new00
7566 static int tolua_stratagus_ImageRadioButton_new00(lua_State* tolua_S)
7567 {
7568 #ifndef TOLUA_RELEASE
7569 tolua_Error tolua_err;
7570 if (
7571 !tolua_isusertable(tolua_S,1,"ImageRadioButton",0,&tolua_err) ||
7572 !tolua_isnoobj(tolua_S,2,&tolua_err)
7573 )
7574 goto tolua_lerror;
7575 else
7576 #endif
7577 {
7578 {
7579 ImageRadioButton* tolua_ret = (ImageRadioButton*) Mtolua_new((ImageRadioButton)());
7580 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageRadioButton");
7581 }
7582 }
7583 return 1;
7584 #ifndef TOLUA_RELEASE
7585 tolua_lerror:
7586 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7587 return 0;
7588 #endif
7589 }
7590 #endif //#ifndef TOLUA_DISABLE
7591
7592 /* method: new_local of class ImageRadioButton */
7593 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageRadioButton_new00_local
7594 static int tolua_stratagus_ImageRadioButton_new00_local(lua_State* tolua_S)
7595 {
7596 #ifndef TOLUA_RELEASE
7597 tolua_Error tolua_err;
7598 if (
7599 !tolua_isusertable(tolua_S,1,"ImageRadioButton",0,&tolua_err) ||
7600 !tolua_isnoobj(tolua_S,2,&tolua_err)
7601 )
7602 goto tolua_lerror;
7603 else
7604 #endif
7605 {
7606 {
7607 ImageRadioButton* tolua_ret = (ImageRadioButton*) Mtolua_new((ImageRadioButton)());
7608 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageRadioButton");
7609 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7610 }
7611 }
7612 return 1;
7613 #ifndef TOLUA_RELEASE
7614 tolua_lerror:
7615 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7616 return 0;
7617 #endif
7618 }
7619 #endif //#ifndef TOLUA_DISABLE
7620
7621 /* method: new of class ImageRadioButton */
7622 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageRadioButton_new01
7623 static int tolua_stratagus_ImageRadioButton_new01(lua_State* tolua_S)
7624 {
7625 tolua_Error tolua_err;
7626 if (
7627 !tolua_isusertable(tolua_S,1,"ImageRadioButton",0,&tolua_err) ||
7628 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7629 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
7630 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
7631 !tolua_isnoobj(tolua_S,5,&tolua_err)
7632 )
7633 goto tolua_lerror;
7634 else
7635 {
7636 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7637 const std::string group = ((const std::string) tolua_tocppstring(tolua_S,3,0));
7638 bool marked = ((bool) tolua_toboolean(tolua_S,4,false));
7639 {
7640 ImageRadioButton* tolua_ret = (ImageRadioButton*) Mtolua_new((ImageRadioButton)(caption,group,marked));
7641 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageRadioButton");
7642 }
7643 }
7644 return 1;
7645 tolua_lerror:
7646 return tolua_stratagus_ImageRadioButton_new00(tolua_S);
7647 }
7648 #endif //#ifndef TOLUA_DISABLE
7649
7650 /* method: new_local of class ImageRadioButton */
7651 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageRadioButton_new01_local
7652 static int tolua_stratagus_ImageRadioButton_new01_local(lua_State* tolua_S)
7653 {
7654 tolua_Error tolua_err;
7655 if (
7656 !tolua_isusertable(tolua_S,1,"ImageRadioButton",0,&tolua_err) ||
7657 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7658 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
7659 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
7660 !tolua_isnoobj(tolua_S,5,&tolua_err)
7661 )
7662 goto tolua_lerror;
7663 else
7664 {
7665 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7666 const std::string group = ((const std::string) tolua_tocppstring(tolua_S,3,0));
7667 bool marked = ((bool) tolua_toboolean(tolua_S,4,false));
7668 {
7669 ImageRadioButton* tolua_ret = (ImageRadioButton*) Mtolua_new((ImageRadioButton)(caption,group,marked));
7670 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageRadioButton");
7671 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7672 }
7673 }
7674 return 1;
7675 tolua_lerror:
7676 return tolua_stratagus_ImageRadioButton_new00_local(tolua_S);
7677 }
7678 #endif //#ifndef TOLUA_DISABLE
7679
7680 /* method: setUncheckedNormalImage of class ImageRadioButton */
7681 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageRadioButton_setUncheckedNormalImage00
7682 static int tolua_stratagus_ImageRadioButton_setUncheckedNormalImage00(lua_State* tolua_S)
7683 {
7684 #ifndef TOLUA_RELEASE
7685 tolua_Error tolua_err;
7686 if (
7687 !tolua_isusertype(tolua_S,1,"ImageRadioButton",0,&tolua_err) ||
7688 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
7689 !tolua_isnoobj(tolua_S,3,&tolua_err)
7690 )
7691 goto tolua_lerror;
7692 else
7693 #endif
7694 {
7695 ImageRadioButton* self = (ImageRadioButton*) tolua_tousertype(tolua_S,1,0);
7696 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
7697 #ifndef TOLUA_RELEASE
7698 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUncheckedNormalImage'", NULL);
7699 #endif
7700 {
7701 self->setUncheckedNormalImage(image);
7702 }
7703 }
7704 return 0;
7705 #ifndef TOLUA_RELEASE
7706 tolua_lerror:
7707 tolua_error(tolua_S,"#ferror in function 'setUncheckedNormalImage'.",&tolua_err);
7708 return 0;
7709 #endif
7710 }
7711 #endif //#ifndef TOLUA_DISABLE
7712
7713 /* method: setUncheckedPressedImage of class ImageRadioButton */
7714 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageRadioButton_setUncheckedPressedImage00
7715 static int tolua_stratagus_ImageRadioButton_setUncheckedPressedImage00(lua_State* tolua_S)
7716 {
7717 #ifndef TOLUA_RELEASE
7718 tolua_Error tolua_err;
7719 if (
7720 !tolua_isusertype(tolua_S,1,"ImageRadioButton",0,&tolua_err) ||
7721 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
7722 !tolua_isnoobj(tolua_S,3,&tolua_err)
7723 )
7724 goto tolua_lerror;
7725 else
7726 #endif
7727 {
7728 ImageRadioButton* self = (ImageRadioButton*) tolua_tousertype(tolua_S,1,0);
7729 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
7730 #ifndef TOLUA_RELEASE
7731 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUncheckedPressedImage'", NULL);
7732 #endif
7733 {
7734 self->setUncheckedPressedImage(image);
7735 }
7736 }
7737 return 0;
7738 #ifndef TOLUA_RELEASE
7739 tolua_lerror:
7740 tolua_error(tolua_S,"#ferror in function 'setUncheckedPressedImage'.",&tolua_err);
7741 return 0;
7742 #endif
7743 }
7744 #endif //#ifndef TOLUA_DISABLE
7745
7746 /* method: setCheckedNormalImage of class ImageRadioButton */
7747 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageRadioButton_setCheckedNormalImage00
7748 static int tolua_stratagus_ImageRadioButton_setCheckedNormalImage00(lua_State* tolua_S)
7749 {
7750 #ifndef TOLUA_RELEASE
7751 tolua_Error tolua_err;
7752 if (
7753 !tolua_isusertype(tolua_S,1,"ImageRadioButton",0,&tolua_err) ||
7754 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
7755 !tolua_isnoobj(tolua_S,3,&tolua_err)
7756 )
7757 goto tolua_lerror;
7758 else
7759 #endif
7760 {
7761 ImageRadioButton* self = (ImageRadioButton*) tolua_tousertype(tolua_S,1,0);
7762 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
7763 #ifndef TOLUA_RELEASE
7764 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCheckedNormalImage'", NULL);
7765 #endif
7766 {
7767 self->setCheckedNormalImage(image);
7768 }
7769 }
7770 return 0;
7771 #ifndef TOLUA_RELEASE
7772 tolua_lerror:
7773 tolua_error(tolua_S,"#ferror in function 'setCheckedNormalImage'.",&tolua_err);
7774 return 0;
7775 #endif
7776 }
7777 #endif //#ifndef TOLUA_DISABLE
7778
7779 /* method: setCheckedPressedImage of class ImageRadioButton */
7780 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageRadioButton_setCheckedPressedImage00
7781 static int tolua_stratagus_ImageRadioButton_setCheckedPressedImage00(lua_State* tolua_S)
7782 {
7783 #ifndef TOLUA_RELEASE
7784 tolua_Error tolua_err;
7785 if (
7786 !tolua_isusertype(tolua_S,1,"ImageRadioButton",0,&tolua_err) ||
7787 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
7788 !tolua_isnoobj(tolua_S,3,&tolua_err)
7789 )
7790 goto tolua_lerror;
7791 else
7792 #endif
7793 {
7794 ImageRadioButton* self = (ImageRadioButton*) tolua_tousertype(tolua_S,1,0);
7795 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
7796 #ifndef TOLUA_RELEASE
7797 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCheckedPressedImage'", NULL);
7798 #endif
7799 {
7800 self->setCheckedPressedImage(image);
7801 }
7802 }
7803 return 0;
7804 #ifndef TOLUA_RELEASE
7805 tolua_lerror:
7806 tolua_error(tolua_S,"#ferror in function 'setCheckedPressedImage'.",&tolua_err);
7807 return 0;
7808 #endif
7809 }
7810 #endif //#ifndef TOLUA_DISABLE
7811
7812 /* method: new of class CheckBox */
7813 #ifndef TOLUA_DISABLE_tolua_stratagus_CheckBox_new00
7814 static int tolua_stratagus_CheckBox_new00(lua_State* tolua_S)
7815 {
7816 #ifndef TOLUA_RELEASE
7817 tolua_Error tolua_err;
7818 if (
7819 !tolua_isusertable(tolua_S,1,"CheckBox",0,&tolua_err) ||
7820 !tolua_isnoobj(tolua_S,2,&tolua_err)
7821 )
7822 goto tolua_lerror;
7823 else
7824 #endif
7825 {
7826 {
7827 CheckBox* tolua_ret = (CheckBox*) Mtolua_new((CheckBox)());
7828 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CheckBox");
7829 }
7830 }
7831 return 1;
7832 #ifndef TOLUA_RELEASE
7833 tolua_lerror:
7834 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7835 return 0;
7836 #endif
7837 }
7838 #endif //#ifndef TOLUA_DISABLE
7839
7840 /* method: new_local of class CheckBox */
7841 #ifndef TOLUA_DISABLE_tolua_stratagus_CheckBox_new00_local
7842 static int tolua_stratagus_CheckBox_new00_local(lua_State* tolua_S)
7843 {
7844 #ifndef TOLUA_RELEASE
7845 tolua_Error tolua_err;
7846 if (
7847 !tolua_isusertable(tolua_S,1,"CheckBox",0,&tolua_err) ||
7848 !tolua_isnoobj(tolua_S,2,&tolua_err)
7849 )
7850 goto tolua_lerror;
7851 else
7852 #endif
7853 {
7854 {
7855 CheckBox* tolua_ret = (CheckBox*) Mtolua_new((CheckBox)());
7856 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CheckBox");
7857 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7858 }
7859 }
7860 return 1;
7861 #ifndef TOLUA_RELEASE
7862 tolua_lerror:
7863 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7864 return 0;
7865 #endif
7866 }
7867 #endif //#ifndef TOLUA_DISABLE
7868
7869 /* method: new of class CheckBox */
7870 #ifndef TOLUA_DISABLE_tolua_stratagus_CheckBox_new01
7871 static int tolua_stratagus_CheckBox_new01(lua_State* tolua_S)
7872 {
7873 tolua_Error tolua_err;
7874 if (
7875 !tolua_isusertable(tolua_S,1,"CheckBox",0,&tolua_err) ||
7876 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7877 !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
7878 !tolua_isnoobj(tolua_S,4,&tolua_err)
7879 )
7880 goto tolua_lerror;
7881 else
7882 {
7883 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7884 bool marked = ((bool) tolua_toboolean(tolua_S,3,false));
7885 {
7886 CheckBox* tolua_ret = (CheckBox*) Mtolua_new((CheckBox)(caption,marked));
7887 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CheckBox");
7888 }
7889 }
7890 return 1;
7891 tolua_lerror:
7892 return tolua_stratagus_CheckBox_new00(tolua_S);
7893 }
7894 #endif //#ifndef TOLUA_DISABLE
7895
7896 /* method: new_local of class CheckBox */
7897 #ifndef TOLUA_DISABLE_tolua_stratagus_CheckBox_new01_local
7898 static int tolua_stratagus_CheckBox_new01_local(lua_State* tolua_S)
7899 {
7900 tolua_Error tolua_err;
7901 if (
7902 !tolua_isusertable(tolua_S,1,"CheckBox",0,&tolua_err) ||
7903 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7904 !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
7905 !tolua_isnoobj(tolua_S,4,&tolua_err)
7906 )
7907 goto tolua_lerror;
7908 else
7909 {
7910 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7911 bool marked = ((bool) tolua_toboolean(tolua_S,3,false));
7912 {
7913 CheckBox* tolua_ret = (CheckBox*) Mtolua_new((CheckBox)(caption,marked));
7914 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CheckBox");
7915 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7916 }
7917 }
7918 return 1;
7919 tolua_lerror:
7920 return tolua_stratagus_CheckBox_new00_local(tolua_S);
7921 }
7922 #endif //#ifndef TOLUA_DISABLE
7923
7924 /* method: isMarked of class CheckBox */
7925 #ifndef TOLUA_DISABLE_tolua_stratagus_CheckBox_isMarked00
7926 static int tolua_stratagus_CheckBox_isMarked00(lua_State* tolua_S)
7927 {
7928 #ifndef TOLUA_RELEASE
7929 tolua_Error tolua_err;
7930 if (
7931 !tolua_isusertype(tolua_S,1,"const CheckBox",0,&tolua_err) ||
7932 !tolua_isnoobj(tolua_S,2,&tolua_err)
7933 )
7934 goto tolua_lerror;
7935 else
7936 #endif
7937 {
7938 const CheckBox* self = (const CheckBox*) tolua_tousertype(tolua_S,1,0);
7939 #ifndef TOLUA_RELEASE
7940 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isMarked'", NULL);
7941 #endif
7942 {
7943 bool tolua_ret = (bool) self->isMarked();
7944 tolua_pushboolean(tolua_S,(bool)tolua_ret);
7945 }
7946 }
7947 return 1;
7948 #ifndef TOLUA_RELEASE
7949 tolua_lerror:
7950 tolua_error(tolua_S,"#ferror in function 'isMarked'.",&tolua_err);
7951 return 0;
7952 #endif
7953 }
7954 #endif //#ifndef TOLUA_DISABLE
7955
7956 /* method: setMarked of class CheckBox */
7957 #ifndef TOLUA_DISABLE_tolua_stratagus_CheckBox_setMarked00
7958 static int tolua_stratagus_CheckBox_setMarked00(lua_State* tolua_S)
7959 {
7960 #ifndef TOLUA_RELEASE
7961 tolua_Error tolua_err;
7962 if (
7963 !tolua_isusertype(tolua_S,1,"CheckBox",0,&tolua_err) ||
7964 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
7965 !tolua_isnoobj(tolua_S,3,&tolua_err)
7966 )
7967 goto tolua_lerror;
7968 else
7969 #endif
7970 {
7971 CheckBox* self = (CheckBox*) tolua_tousertype(tolua_S,1,0);
7972 bool marked = ((bool) tolua_toboolean(tolua_S,2,0));
7973 #ifndef TOLUA_RELEASE
7974 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMarked'", NULL);
7975 #endif
7976 {
7977 self->setMarked(marked);
7978 }
7979 }
7980 return 0;
7981 #ifndef TOLUA_RELEASE
7982 tolua_lerror:
7983 tolua_error(tolua_S,"#ferror in function 'setMarked'.",&tolua_err);
7984 return 0;
7985 #endif
7986 }
7987 #endif //#ifndef TOLUA_DISABLE
7988
7989 /* method: getCaption of class CheckBox */
7990 #ifndef TOLUA_DISABLE_tolua_stratagus_CheckBox_getCaption00
7991 static int tolua_stratagus_CheckBox_getCaption00(lua_State* tolua_S)
7992 {
7993 #ifndef TOLUA_RELEASE
7994 tolua_Error tolua_err;
7995 if (
7996 !tolua_isusertype(tolua_S,1,"const CheckBox",0,&tolua_err) ||
7997 !tolua_isnoobj(tolua_S,2,&tolua_err)
7998 )
7999 goto tolua_lerror;
8000 else
8001 #endif
8002 {
8003 const CheckBox* self = (const CheckBox*) tolua_tousertype(tolua_S,1,0);
8004 #ifndef TOLUA_RELEASE
8005 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaption'", NULL);
8006 #endif
8007 {
8008 const std::string tolua_ret = (const std::string) self->getCaption();
8009 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
8010 }
8011 }
8012 return 1;
8013 #ifndef TOLUA_RELEASE
8014 tolua_lerror:
8015 tolua_error(tolua_S,"#ferror in function 'getCaption'.",&tolua_err);
8016 return 0;
8017 #endif
8018 }
8019 #endif //#ifndef TOLUA_DISABLE
8020
8021 /* method: setCaption of class CheckBox */
8022 #ifndef TOLUA_DISABLE_tolua_stratagus_CheckBox_setCaption00
8023 static int tolua_stratagus_CheckBox_setCaption00(lua_State* tolua_S)
8024 {
8025 #ifndef TOLUA_RELEASE
8026 tolua_Error tolua_err;
8027 if (
8028 !tolua_isusertype(tolua_S,1,"CheckBox",0,&tolua_err) ||
8029 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
8030 !tolua_isnoobj(tolua_S,3,&tolua_err)
8031 )
8032 goto tolua_lerror;
8033 else
8034 #endif
8035 {
8036 CheckBox* self = (CheckBox*) tolua_tousertype(tolua_S,1,0);
8037 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
8038 #ifndef TOLUA_RELEASE
8039 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaption'", NULL);
8040 #endif
8041 {
8042 self->setCaption(caption);
8043 }
8044 }
8045 return 0;
8046 #ifndef TOLUA_RELEASE
8047 tolua_lerror:
8048 tolua_error(tolua_S,"#ferror in function 'setCaption'.",&tolua_err);
8049 return 0;
8050 #endif
8051 }
8052 #endif //#ifndef TOLUA_DISABLE
8053
8054 /* method: adjustSize of class CheckBox */
8055 #ifndef TOLUA_DISABLE_tolua_stratagus_CheckBox_adjustSize00
8056 static int tolua_stratagus_CheckBox_adjustSize00(lua_State* tolua_S)
8057 {
8058 #ifndef TOLUA_RELEASE
8059 tolua_Error tolua_err;
8060 if (
8061 !tolua_isusertype(tolua_S,1,"CheckBox",0,&tolua_err) ||
8062 !tolua_isnoobj(tolua_S,2,&tolua_err)
8063 )
8064 goto tolua_lerror;
8065 else
8066 #endif
8067 {
8068 CheckBox* self = (CheckBox*) tolua_tousertype(tolua_S,1,0);
8069 #ifndef TOLUA_RELEASE
8070 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'adjustSize'", NULL);
8071 #endif
8072 {
8073 self->adjustSize();
8074 }
8075 }
8076 return 0;
8077 #ifndef TOLUA_RELEASE
8078 tolua_lerror:
8079 tolua_error(tolua_S,"#ferror in function 'adjustSize'.",&tolua_err);
8080 return 0;
8081 #endif
8082 }
8083 #endif //#ifndef TOLUA_DISABLE
8084
8085 /* method: new of class ImageCheckBox */
8086 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageCheckBox_new00
8087 static int tolua_stratagus_ImageCheckBox_new00(lua_State* tolua_S)
8088 {
8089 #ifndef TOLUA_RELEASE
8090 tolua_Error tolua_err;
8091 if (
8092 !tolua_isusertable(tolua_S,1,"ImageCheckBox",0,&tolua_err) ||
8093 !tolua_isnoobj(tolua_S,2,&tolua_err)
8094 )
8095 goto tolua_lerror;
8096 else
8097 #endif
8098 {
8099 {
8100 ImageCheckBox* tolua_ret = (ImageCheckBox*) Mtolua_new((ImageCheckBox)());
8101 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageCheckBox");
8102 }
8103 }
8104 return 1;
8105 #ifndef TOLUA_RELEASE
8106 tolua_lerror:
8107 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8108 return 0;
8109 #endif
8110 }
8111 #endif //#ifndef TOLUA_DISABLE
8112
8113 /* method: new_local of class ImageCheckBox */
8114 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageCheckBox_new00_local
8115 static int tolua_stratagus_ImageCheckBox_new00_local(lua_State* tolua_S)
8116 {
8117 #ifndef TOLUA_RELEASE
8118 tolua_Error tolua_err;
8119 if (
8120 !tolua_isusertable(tolua_S,1,"ImageCheckBox",0,&tolua_err) ||
8121 !tolua_isnoobj(tolua_S,2,&tolua_err)
8122 )
8123 goto tolua_lerror;
8124 else
8125 #endif
8126 {
8127 {
8128 ImageCheckBox* tolua_ret = (ImageCheckBox*) Mtolua_new((ImageCheckBox)());
8129 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageCheckBox");
8130 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
8131 }
8132 }
8133 return 1;
8134 #ifndef TOLUA_RELEASE
8135 tolua_lerror:
8136 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8137 return 0;
8138 #endif
8139 }
8140 #endif //#ifndef TOLUA_DISABLE
8141
8142 /* method: new of class ImageCheckBox */
8143 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageCheckBox_new01
8144 static int tolua_stratagus_ImageCheckBox_new01(lua_State* tolua_S)
8145 {
8146 tolua_Error tolua_err;
8147 if (
8148 !tolua_isusertable(tolua_S,1,"ImageCheckBox",0,&tolua_err) ||
8149 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
8150 !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
8151 !tolua_isnoobj(tolua_S,4,&tolua_err)
8152 )
8153 goto tolua_lerror;
8154 else
8155 {
8156 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
8157 bool marked = ((bool) tolua_toboolean(tolua_S,3,false));
8158 {
8159 ImageCheckBox* tolua_ret = (ImageCheckBox*) Mtolua_new((ImageCheckBox)(caption,marked));
8160 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageCheckBox");
8161 }
8162 }
8163 return 1;
8164 tolua_lerror:
8165 return tolua_stratagus_ImageCheckBox_new00(tolua_S);
8166 }
8167 #endif //#ifndef TOLUA_DISABLE
8168
8169 /* method: new_local of class ImageCheckBox */
8170 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageCheckBox_new01_local
8171 static int tolua_stratagus_ImageCheckBox_new01_local(lua_State* tolua_S)
8172 {
8173 tolua_Error tolua_err;
8174 if (
8175 !tolua_isusertable(tolua_S,1,"ImageCheckBox",0,&tolua_err) ||
8176 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
8177 !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
8178 !tolua_isnoobj(tolua_S,4,&tolua_err)
8179 )
8180 goto tolua_lerror;
8181 else
8182 {
8183 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
8184 bool marked = ((bool) tolua_toboolean(tolua_S,3,false));
8185 {
8186 ImageCheckBox* tolua_ret = (ImageCheckBox*) Mtolua_new((ImageCheckBox)(caption,marked));
8187 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageCheckBox");
8188 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
8189 }
8190 }
8191 return 1;
8192 tolua_lerror:
8193 return tolua_stratagus_ImageCheckBox_new00_local(tolua_S);
8194 }
8195 #endif //#ifndef TOLUA_DISABLE
8196
8197 /* method: setUncheckedNormalImage of class ImageCheckBox */
8198 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageCheckBox_setUncheckedNormalImage00
8199 static int tolua_stratagus_ImageCheckBox_setUncheckedNormalImage00(lua_State* tolua_S)
8200 {
8201 #ifndef TOLUA_RELEASE
8202 tolua_Error tolua_err;
8203 if (
8204 !tolua_isusertype(tolua_S,1,"ImageCheckBox",0,&tolua_err) ||
8205 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
8206 !tolua_isnoobj(tolua_S,3,&tolua_err)
8207 )
8208 goto tolua_lerror;
8209 else
8210 #endif
8211 {
8212 ImageCheckBox* self = (ImageCheckBox*) tolua_tousertype(tolua_S,1,0);
8213 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
8214 #ifndef TOLUA_RELEASE
8215 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUncheckedNormalImage'", NULL);
8216 #endif
8217 {
8218 self->setUncheckedNormalImage(image);
8219 }
8220 }
8221 return 0;
8222 #ifndef TOLUA_RELEASE
8223 tolua_lerror:
8224 tolua_error(tolua_S,"#ferror in function 'setUncheckedNormalImage'.",&tolua_err);
8225 return 0;
8226 #endif
8227 }
8228 #endif //#ifndef TOLUA_DISABLE
8229
8230 /* method: setUncheckedPressedImage of class ImageCheckBox */
8231 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageCheckBox_setUncheckedPressedImage00
8232 static int tolua_stratagus_ImageCheckBox_setUncheckedPressedImage00(lua_State* tolua_S)
8233 {
8234 #ifndef TOLUA_RELEASE
8235 tolua_Error tolua_err;
8236 if (
8237 !tolua_isusertype(tolua_S,1,"ImageCheckBox",0,&tolua_err) ||
8238 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
8239 !tolua_isnoobj(tolua_S,3,&tolua_err)
8240 )
8241 goto tolua_lerror;
8242 else
8243 #endif
8244 {
8245 ImageCheckBox* self = (ImageCheckBox*) tolua_tousertype(tolua_S,1,0);
8246 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
8247 #ifndef TOLUA_RELEASE
8248 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUncheckedPressedImage'", NULL);
8249 #endif
8250 {
8251 self->setUncheckedPressedImage(image);
8252 }
8253 }
8254 return 0;
8255 #ifndef TOLUA_RELEASE
8256 tolua_lerror:
8257 tolua_error(tolua_S,"#ferror in function 'setUncheckedPressedImage'.",&tolua_err);
8258 return 0;
8259 #endif
8260 }
8261 #endif //#ifndef TOLUA_DISABLE
8262
8263 /* method: setCheckedNormalImage of class ImageCheckBox */
8264 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageCheckBox_setCheckedNormalImage00
8265 static int tolua_stratagus_ImageCheckBox_setCheckedNormalImage00(lua_State* tolua_S)
8266 {
8267 #ifndef TOLUA_RELEASE
8268 tolua_Error tolua_err;
8269 if (
8270 !tolua_isusertype(tolua_S,1,"ImageCheckBox",0,&tolua_err) ||
8271 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
8272 !tolua_isnoobj(tolua_S,3,&tolua_err)
8273 )
8274 goto tolua_lerror;
8275 else
8276 #endif
8277 {
8278 ImageCheckBox* self = (ImageCheckBox*) tolua_tousertype(tolua_S,1,0);
8279 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
8280 #ifndef TOLUA_RELEASE
8281 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCheckedNormalImage'", NULL);
8282 #endif
8283 {
8284 self->setCheckedNormalImage(image);
8285 }
8286 }
8287 return 0;
8288 #ifndef TOLUA_RELEASE
8289 tolua_lerror:
8290 tolua_error(tolua_S,"#ferror in function 'setCheckedNormalImage'.",&tolua_err);
8291 return 0;
8292 #endif
8293 }
8294 #endif //#ifndef TOLUA_DISABLE
8295
8296 /* method: setCheckedPressedImage of class ImageCheckBox */
8297 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageCheckBox_setCheckedPressedImage00
8298 static int tolua_stratagus_ImageCheckBox_setCheckedPressedImage00(lua_State* tolua_S)
8299 {
8300 #ifndef TOLUA_RELEASE
8301 tolua_Error tolua_err;
8302 if (
8303 !tolua_isusertype(tolua_S,1,"ImageCheckBox",0,&tolua_err) ||
8304 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
8305 !tolua_isnoobj(tolua_S,3,&tolua_err)
8306 )
8307 goto tolua_lerror;
8308 else
8309 #endif
8310 {
8311 ImageCheckBox* self = (ImageCheckBox*) tolua_tousertype(tolua_S,1,0);
8312 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
8313 #ifndef TOLUA_RELEASE
8314 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCheckedPressedImage'", NULL);
8315 #endif
8316 {
8317 self->setCheckedPressedImage(image);
8318 }
8319 }
8320 return 0;
8321 #ifndef TOLUA_RELEASE
8322 tolua_lerror:
8323 tolua_error(tolua_S,"#ferror in function 'setCheckedPressedImage'.",&tolua_err);
8324 return 0;
8325 #endif
8326 }
8327 #endif //#ifndef TOLUA_DISABLE
8328
8329 /* method: new of class Slider */
8330 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_new00
8331 static int tolua_stratagus_Slider_new00(lua_State* tolua_S)
8332 {
8333 #ifndef TOLUA_RELEASE
8334 tolua_Error tolua_err;
8335 if (
8336 !tolua_isusertable(tolua_S,1,"Slider",0,&tolua_err) ||
8337 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
8338 !tolua_isnoobj(tolua_S,3,&tolua_err)
8339 )
8340 goto tolua_lerror;
8341 else
8342 #endif
8343 {
8344 double scaleEnd = ((double) tolua_tonumber(tolua_S,2,1.0));
8345 {
8346 Slider* tolua_ret = (Slider*) Mtolua_new((Slider)(scaleEnd));
8347 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Slider");
8348 }
8349 }
8350 return 1;
8351 #ifndef TOLUA_RELEASE
8352 tolua_lerror:
8353 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8354 return 0;
8355 #endif
8356 }
8357 #endif //#ifndef TOLUA_DISABLE
8358
8359 /* method: new_local of class Slider */
8360 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_new00_local
8361 static int tolua_stratagus_Slider_new00_local(lua_State* tolua_S)
8362 {
8363 #ifndef TOLUA_RELEASE
8364 tolua_Error tolua_err;
8365 if (
8366 !tolua_isusertable(tolua_S,1,"Slider",0,&tolua_err) ||
8367 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
8368 !tolua_isnoobj(tolua_S,3,&tolua_err)
8369 )
8370 goto tolua_lerror;
8371 else
8372 #endif
8373 {
8374 double scaleEnd = ((double) tolua_tonumber(tolua_S,2,1.0));
8375 {
8376 Slider* tolua_ret = (Slider*) Mtolua_new((Slider)(scaleEnd));
8377 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Slider");
8378 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
8379 }
8380 }
8381 return 1;
8382 #ifndef TOLUA_RELEASE
8383 tolua_lerror:
8384 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8385 return 0;
8386 #endif
8387 }
8388 #endif //#ifndef TOLUA_DISABLE
8389
8390 /* method: new of class Slider */
8391 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_new01
8392 static int tolua_stratagus_Slider_new01(lua_State* tolua_S)
8393 {
8394 tolua_Error tolua_err;
8395 if (
8396 !tolua_isusertable(tolua_S,1,"Slider",0,&tolua_err) ||
8397 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8398 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
8399 !tolua_isnoobj(tolua_S,4,&tolua_err)
8400 )
8401 goto tolua_lerror;
8402 else
8403 {
8404 double scaleStart = ((double) tolua_tonumber(tolua_S,2,0));
8405 double scaleEnd = ((double) tolua_tonumber(tolua_S,3,0));
8406 {
8407 Slider* tolua_ret = (Slider*) Mtolua_new((Slider)(scaleStart,scaleEnd));
8408 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Slider");
8409 }
8410 }
8411 return 1;
8412 tolua_lerror:
8413 return tolua_stratagus_Slider_new00(tolua_S);
8414 }
8415 #endif //#ifndef TOLUA_DISABLE
8416
8417 /* method: new_local of class Slider */
8418 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_new01_local
8419 static int tolua_stratagus_Slider_new01_local(lua_State* tolua_S)
8420 {
8421 tolua_Error tolua_err;
8422 if (
8423 !tolua_isusertable(tolua_S,1,"Slider",0,&tolua_err) ||
8424 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8425 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
8426 !tolua_isnoobj(tolua_S,4,&tolua_err)
8427 )
8428 goto tolua_lerror;
8429 else
8430 {
8431 double scaleStart = ((double) tolua_tonumber(tolua_S,2,0));
8432 double scaleEnd = ((double) tolua_tonumber(tolua_S,3,0));
8433 {
8434 Slider* tolua_ret = (Slider*) Mtolua_new((Slider)(scaleStart,scaleEnd));
8435 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Slider");
8436 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
8437 }
8438 }
8439 return 1;
8440 tolua_lerror:
8441 return tolua_stratagus_Slider_new00_local(tolua_S);
8442 }
8443 #endif //#ifndef TOLUA_DISABLE
8444
8445 /* method: setScale of class Slider */
8446 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_setScale00
8447 static int tolua_stratagus_Slider_setScale00(lua_State* tolua_S)
8448 {
8449 #ifndef TOLUA_RELEASE
8450 tolua_Error tolua_err;
8451 if (
8452 !tolua_isusertype(tolua_S,1,"Slider",0,&tolua_err) ||
8453 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8454 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
8455 !tolua_isnoobj(tolua_S,4,&tolua_err)
8456 )
8457 goto tolua_lerror;
8458 else
8459 #endif
8460 {
8461 Slider* self = (Slider*) tolua_tousertype(tolua_S,1,0);
8462 double scaleStart = ((double) tolua_tonumber(tolua_S,2,0));
8463 double scaleEnd = ((double) tolua_tonumber(tolua_S,3,0));
8464 #ifndef TOLUA_RELEASE
8465 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setScale'", NULL);
8466 #endif
8467 {
8468 self->setScale(scaleStart,scaleEnd);
8469 }
8470 }
8471 return 0;
8472 #ifndef TOLUA_RELEASE
8473 tolua_lerror:
8474 tolua_error(tolua_S,"#ferror in function 'setScale'.",&tolua_err);
8475 return 0;
8476 #endif
8477 }
8478 #endif //#ifndef TOLUA_DISABLE
8479
8480 /* method: getScaleStart of class Slider */
8481 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_getScaleStart00
8482 static int tolua_stratagus_Slider_getScaleStart00(lua_State* tolua_S)
8483 {
8484 #ifndef TOLUA_RELEASE
8485 tolua_Error tolua_err;
8486 if (
8487 !tolua_isusertype(tolua_S,1,"const Slider",0,&tolua_err) ||
8488 !tolua_isnoobj(tolua_S,2,&tolua_err)
8489 )
8490 goto tolua_lerror;
8491 else
8492 #endif
8493 {
8494 const Slider* self = (const Slider*) tolua_tousertype(tolua_S,1,0);
8495 #ifndef TOLUA_RELEASE
8496 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScaleStart'", NULL);
8497 #endif
8498 {
8499 double tolua_ret = (double) self->getScaleStart();
8500 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
8501 }
8502 }
8503 return 1;
8504 #ifndef TOLUA_RELEASE
8505 tolua_lerror:
8506 tolua_error(tolua_S,"#ferror in function 'getScaleStart'.",&tolua_err);
8507 return 0;
8508 #endif
8509 }
8510 #endif //#ifndef TOLUA_DISABLE
8511
8512 /* method: setScaleStart of class Slider */
8513 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_setScaleStart00
8514 static int tolua_stratagus_Slider_setScaleStart00(lua_State* tolua_S)
8515 {
8516 #ifndef TOLUA_RELEASE
8517 tolua_Error tolua_err;
8518 if (
8519 !tolua_isusertype(tolua_S,1,"Slider",0,&tolua_err) ||
8520 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8521 !tolua_isnoobj(tolua_S,3,&tolua_err)
8522 )
8523 goto tolua_lerror;
8524 else
8525 #endif
8526 {
8527 Slider* self = (Slider*) tolua_tousertype(tolua_S,1,0);
8528 double scaleStart = ((double) tolua_tonumber(tolua_S,2,0));
8529 #ifndef TOLUA_RELEASE
8530 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setScaleStart'", NULL);
8531 #endif
8532 {
8533 self->setScaleStart(scaleStart);
8534 }
8535 }
8536 return 0;
8537 #ifndef TOLUA_RELEASE
8538 tolua_lerror:
8539 tolua_error(tolua_S,"#ferror in function 'setScaleStart'.",&tolua_err);
8540 return 0;
8541 #endif
8542 }
8543 #endif //#ifndef TOLUA_DISABLE
8544
8545 /* method: getScaleEnd of class Slider */
8546 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_getScaleEnd00
8547 static int tolua_stratagus_Slider_getScaleEnd00(lua_State* tolua_S)
8548 {
8549 #ifndef TOLUA_RELEASE
8550 tolua_Error tolua_err;
8551 if (
8552 !tolua_isusertype(tolua_S,1,"const Slider",0,&tolua_err) ||
8553 !tolua_isnoobj(tolua_S,2,&tolua_err)
8554 )
8555 goto tolua_lerror;
8556 else
8557 #endif
8558 {
8559 const Slider* self = (const Slider*) tolua_tousertype(tolua_S,1,0);
8560 #ifndef TOLUA_RELEASE
8561 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScaleEnd'", NULL);
8562 #endif
8563 {
8564 double tolua_ret = (double) self->getScaleEnd();
8565 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
8566 }
8567 }
8568 return 1;
8569 #ifndef TOLUA_RELEASE
8570 tolua_lerror:
8571 tolua_error(tolua_S,"#ferror in function 'getScaleEnd'.",&tolua_err);
8572 return 0;
8573 #endif
8574 }
8575 #endif //#ifndef TOLUA_DISABLE
8576
8577 /* method: setScaleEnd of class Slider */
8578 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_setScaleEnd00
8579 static int tolua_stratagus_Slider_setScaleEnd00(lua_State* tolua_S)
8580 {
8581 #ifndef TOLUA_RELEASE
8582 tolua_Error tolua_err;
8583 if (
8584 !tolua_isusertype(tolua_S,1,"Slider",0,&tolua_err) ||
8585 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8586 !tolua_isnoobj(tolua_S,3,&tolua_err)
8587 )
8588 goto tolua_lerror;
8589 else
8590 #endif
8591 {
8592 Slider* self = (Slider*) tolua_tousertype(tolua_S,1,0);
8593 double scaleEnd = ((double) tolua_tonumber(tolua_S,2,0));
8594 #ifndef TOLUA_RELEASE
8595 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setScaleEnd'", NULL);
8596 #endif
8597 {
8598 self->setScaleEnd(scaleEnd);
8599 }
8600 }
8601 return 0;
8602 #ifndef TOLUA_RELEASE
8603 tolua_lerror:
8604 tolua_error(tolua_S,"#ferror in function 'setScaleEnd'.",&tolua_err);
8605 return 0;
8606 #endif
8607 }
8608 #endif //#ifndef TOLUA_DISABLE
8609
8610 /* method: getValue of class Slider */
8611 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_getValue00
8612 static int tolua_stratagus_Slider_getValue00(lua_State* tolua_S)
8613 {
8614 #ifndef TOLUA_RELEASE
8615 tolua_Error tolua_err;
8616 if (
8617 !tolua_isusertype(tolua_S,1,"Slider",0,&tolua_err) ||
8618 !tolua_isnoobj(tolua_S,2,&tolua_err)
8619 )
8620 goto tolua_lerror;
8621 else
8622 #endif
8623 {
8624 Slider* self = (Slider*) tolua_tousertype(tolua_S,1,0);
8625 #ifndef TOLUA_RELEASE
8626 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'", NULL);
8627 #endif
8628 {
8629 double tolua_ret = (double) self->getValue();
8630 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
8631 }
8632 }
8633 return 1;
8634 #ifndef TOLUA_RELEASE
8635 tolua_lerror:
8636 tolua_error(tolua_S,"#ferror in function 'getValue'.",&tolua_err);
8637 return 0;
8638 #endif
8639 }
8640 #endif //#ifndef TOLUA_DISABLE
8641
8642 /* method: setValue of class Slider */
8643 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_setValue00
8644 static int tolua_stratagus_Slider_setValue00(lua_State* tolua_S)
8645 {
8646 #ifndef TOLUA_RELEASE
8647 tolua_Error tolua_err;
8648 if (
8649 !tolua_isusertype(tolua_S,1,"Slider",0,&tolua_err) ||
8650 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8651 !tolua_isnoobj(tolua_S,3,&tolua_err)
8652 )
8653 goto tolua_lerror;
8654 else
8655 #endif
8656 {
8657 Slider* self = (Slider*) tolua_tousertype(tolua_S,1,0);
8658 double value = ((double) tolua_tonumber(tolua_S,2,0));
8659 #ifndef TOLUA_RELEASE
8660 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'", NULL);
8661 #endif
8662 {
8663 self->setValue(value);
8664 }
8665 }
8666 return 0;
8667 #ifndef TOLUA_RELEASE
8668 tolua_lerror:
8669 tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
8670 return 0;
8671 #endif
8672 }
8673 #endif //#ifndef TOLUA_DISABLE
8674
8675 /* method: setMarkerLength of class Slider */
8676 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_setMarkerLength00
8677 static int tolua_stratagus_Slider_setMarkerLength00(lua_State* tolua_S)
8678 {
8679 #ifndef TOLUA_RELEASE
8680 tolua_Error tolua_err;
8681 if (
8682 !tolua_isusertype(tolua_S,1,"Slider",0,&tolua_err) ||
8683 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8684 !tolua_isnoobj(tolua_S,3,&tolua_err)
8685 )
8686 goto tolua_lerror;
8687 else
8688 #endif
8689 {
8690 Slider* self = (Slider*) tolua_tousertype(tolua_S,1,0);
8691 int length = ((int) tolua_tonumber(tolua_S,2,0));
8692 #ifndef TOLUA_RELEASE
8693 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMarkerLength'", NULL);
8694 #endif
8695 {
8696 self->setMarkerLength(length);
8697 }
8698 }
8699 return 0;
8700 #ifndef TOLUA_RELEASE
8701 tolua_lerror:
8702 tolua_error(tolua_S,"#ferror in function 'setMarkerLength'.",&tolua_err);
8703 return 0;
8704 #endif
8705 }
8706 #endif //#ifndef TOLUA_DISABLE
8707
8708 /* method: getMarkerLength of class Slider */
8709 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_getMarkerLength00
8710 static int tolua_stratagus_Slider_getMarkerLength00(lua_State* tolua_S)
8711 {
8712 #ifndef TOLUA_RELEASE
8713 tolua_Error tolua_err;
8714 if (
8715 !tolua_isusertype(tolua_S,1,"const Slider",0,&tolua_err) ||
8716 !tolua_isnoobj(tolua_S,2,&tolua_err)
8717 )
8718 goto tolua_lerror;
8719 else
8720 #endif
8721 {
8722 const Slider* self = (const Slider*) tolua_tousertype(tolua_S,1,0);
8723 #ifndef TOLUA_RELEASE
8724 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMarkerLength'", NULL);
8725 #endif
8726 {
8727 int tolua_ret = (int) self->getMarkerLength();
8728 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
8729 }
8730 }
8731 return 1;
8732 #ifndef TOLUA_RELEASE
8733 tolua_lerror:
8734 tolua_error(tolua_S,"#ferror in function 'getMarkerLength'.",&tolua_err);
8735 return 0;
8736 #endif
8737 }
8738 #endif //#ifndef TOLUA_DISABLE
8739
8740 /* method: setOrientation of class Slider */
8741 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_setOrientation00
8742 static int tolua_stratagus_Slider_setOrientation00(lua_State* tolua_S)
8743 {
8744 #ifndef TOLUA_RELEASE
8745 tolua_Error tolua_err;
8746 if (
8747 !tolua_isusertype(tolua_S,1,"Slider",0,&tolua_err) ||
8748 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8749 !tolua_isnoobj(tolua_S,3,&tolua_err)
8750 )
8751 goto tolua_lerror;
8752 else
8753 #endif
8754 {
8755 Slider* self = (Slider*) tolua_tousertype(tolua_S,1,0);
8756 unsigned int orientation = ((unsigned int) tolua_tonumber(tolua_S,2,0));
8757 #ifndef TOLUA_RELEASE
8758 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOrientation'", NULL);
8759 #endif
8760 {
8761 self->setOrientation(orientation);
8762 }
8763 }
8764 return 0;
8765 #ifndef TOLUA_RELEASE
8766 tolua_lerror:
8767 tolua_error(tolua_S,"#ferror in function 'setOrientation'.",&tolua_err);
8768 return 0;
8769 #endif
8770 }
8771 #endif //#ifndef TOLUA_DISABLE
8772
8773 /* method: getOrientation of class Slider */
8774 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_getOrientation00
8775 static int tolua_stratagus_Slider_getOrientation00(lua_State* tolua_S)
8776 {
8777 #ifndef TOLUA_RELEASE
8778 tolua_Error tolua_err;
8779 if (
8780 !tolua_isusertype(tolua_S,1,"const Slider",0,&tolua_err) ||
8781 !tolua_isnoobj(tolua_S,2,&tolua_err)
8782 )
8783 goto tolua_lerror;
8784 else
8785 #endif
8786 {
8787 const Slider* self = (const Slider*) tolua_tousertype(tolua_S,1,0);
8788 #ifndef TOLUA_RELEASE
8789 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOrientation'", NULL);
8790 #endif
8791 {
8792 unsigned int tolua_ret = (unsigned int) self->getOrientation();
8793 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
8794 }
8795 }
8796 return 1;
8797 #ifndef TOLUA_RELEASE
8798 tolua_lerror:
8799 tolua_error(tolua_S,"#ferror in function 'getOrientation'.",&tolua_err);
8800 return 0;
8801 #endif
8802 }
8803 #endif //#ifndef TOLUA_DISABLE
8804
8805 /* method: setStepLength of class Slider */
8806 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_setStepLength00
8807 static int tolua_stratagus_Slider_setStepLength00(lua_State* tolua_S)
8808 {
8809 #ifndef TOLUA_RELEASE
8810 tolua_Error tolua_err;
8811 if (
8812 !tolua_isusertype(tolua_S,1,"Slider",0,&tolua_err) ||
8813 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8814 !tolua_isnoobj(tolua_S,3,&tolua_err)
8815 )
8816 goto tolua_lerror;
8817 else
8818 #endif
8819 {
8820 Slider* self = (Slider*) tolua_tousertype(tolua_S,1,0);
8821 double length = ((double) tolua_tonumber(tolua_S,2,0));
8822 #ifndef TOLUA_RELEASE
8823 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStepLength'", NULL);
8824 #endif
8825 {
8826 self->setStepLength(length);
8827 }
8828 }
8829 return 0;
8830 #ifndef TOLUA_RELEASE
8831 tolua_lerror:
8832 tolua_error(tolua_S,"#ferror in function 'setStepLength'.",&tolua_err);
8833 return 0;
8834 #endif
8835 }
8836 #endif //#ifndef TOLUA_DISABLE
8837
8838 /* method: getStepLength of class Slider */
8839 #ifndef TOLUA_DISABLE_tolua_stratagus_Slider_getStepLength00
8840 static int tolua_stratagus_Slider_getStepLength00(lua_State* tolua_S)
8841 {
8842 #ifndef TOLUA_RELEASE
8843 tolua_Error tolua_err;
8844 if (
8845 !tolua_isusertype(tolua_S,1,"const Slider",0,&tolua_err) ||
8846 !tolua_isnoobj(tolua_S,2,&tolua_err)
8847 )
8848 goto tolua_lerror;
8849 else
8850 #endif
8851 {
8852 const Slider* self = (const Slider*) tolua_tousertype(tolua_S,1,0);
8853 #ifndef TOLUA_RELEASE
8854 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getStepLength'", NULL);
8855 #endif
8856 {
8857 double tolua_ret = (double) self->getStepLength();
8858 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
8859 }
8860 }
8861 return 1;
8862 #ifndef TOLUA_RELEASE
8863 tolua_lerror:
8864 tolua_error(tolua_S,"#ferror in function 'getStepLength'.",&tolua_err);
8865 return 0;
8866 #endif
8867 }
8868 #endif //#ifndef TOLUA_DISABLE
8869
8870 /* method: new of class ImageSlider */
8871 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageSlider_new00
8872 static int tolua_stratagus_ImageSlider_new00(lua_State* tolua_S)
8873 {
8874 #ifndef TOLUA_RELEASE
8875 tolua_Error tolua_err;
8876 if (
8877 !tolua_isusertable(tolua_S,1,"ImageSlider",0,&tolua_err) ||
8878 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
8879 !tolua_isnoobj(tolua_S,3,&tolua_err)
8880 )
8881 goto tolua_lerror;
8882 else
8883 #endif
8884 {
8885 double scaleEnd = ((double) tolua_tonumber(tolua_S,2,1.0));
8886 {
8887 ImageSlider* tolua_ret = (ImageSlider*) Mtolua_new((ImageSlider)(scaleEnd));
8888 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageSlider");
8889 }
8890 }
8891 return 1;
8892 #ifndef TOLUA_RELEASE
8893 tolua_lerror:
8894 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8895 return 0;
8896 #endif
8897 }
8898 #endif //#ifndef TOLUA_DISABLE
8899
8900 /* method: new_local of class ImageSlider */
8901 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageSlider_new00_local
8902 static int tolua_stratagus_ImageSlider_new00_local(lua_State* tolua_S)
8903 {
8904 #ifndef TOLUA_RELEASE
8905 tolua_Error tolua_err;
8906 if (
8907 !tolua_isusertable(tolua_S,1,"ImageSlider",0,&tolua_err) ||
8908 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
8909 !tolua_isnoobj(tolua_S,3,&tolua_err)
8910 )
8911 goto tolua_lerror;
8912 else
8913 #endif
8914 {
8915 double scaleEnd = ((double) tolua_tonumber(tolua_S,2,1.0));
8916 {
8917 ImageSlider* tolua_ret = (ImageSlider*) Mtolua_new((ImageSlider)(scaleEnd));
8918 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageSlider");
8919 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
8920 }
8921 }
8922 return 1;
8923 #ifndef TOLUA_RELEASE
8924 tolua_lerror:
8925 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8926 return 0;
8927 #endif
8928 }
8929 #endif //#ifndef TOLUA_DISABLE
8930
8931 /* method: new of class ImageSlider */
8932 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageSlider_new01
8933 static int tolua_stratagus_ImageSlider_new01(lua_State* tolua_S)
8934 {
8935 tolua_Error tolua_err;
8936 if (
8937 !tolua_isusertable(tolua_S,1,"ImageSlider",0,&tolua_err) ||
8938 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8939 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
8940 !tolua_isnoobj(tolua_S,4,&tolua_err)
8941 )
8942 goto tolua_lerror;
8943 else
8944 {
8945 double scaleStart = ((double) tolua_tonumber(tolua_S,2,0));
8946 double scaleEnd = ((double) tolua_tonumber(tolua_S,3,0));
8947 {
8948 ImageSlider* tolua_ret = (ImageSlider*) Mtolua_new((ImageSlider)(scaleStart,scaleEnd));
8949 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageSlider");
8950 }
8951 }
8952 return 1;
8953 tolua_lerror:
8954 return tolua_stratagus_ImageSlider_new00(tolua_S);
8955 }
8956 #endif //#ifndef TOLUA_DISABLE
8957
8958 /* method: new_local of class ImageSlider */
8959 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageSlider_new01_local
8960 static int tolua_stratagus_ImageSlider_new01_local(lua_State* tolua_S)
8961 {
8962 tolua_Error tolua_err;
8963 if (
8964 !tolua_isusertable(tolua_S,1,"ImageSlider",0,&tolua_err) ||
8965 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8966 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
8967 !tolua_isnoobj(tolua_S,4,&tolua_err)
8968 )
8969 goto tolua_lerror;
8970 else
8971 {
8972 double scaleStart = ((double) tolua_tonumber(tolua_S,2,0));
8973 double scaleEnd = ((double) tolua_tonumber(tolua_S,3,0));
8974 {
8975 ImageSlider* tolua_ret = (ImageSlider*) Mtolua_new((ImageSlider)(scaleStart,scaleEnd));
8976 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ImageSlider");
8977 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
8978 }
8979 }
8980 return 1;
8981 tolua_lerror:
8982 return tolua_stratagus_ImageSlider_new00_local(tolua_S);
8983 }
8984 #endif //#ifndef TOLUA_DISABLE
8985
8986 /* method: setMarkerImage of class ImageSlider */
8987 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageSlider_setMarkerImage00
8988 static int tolua_stratagus_ImageSlider_setMarkerImage00(lua_State* tolua_S)
8989 {
8990 #ifndef TOLUA_RELEASE
8991 tolua_Error tolua_err;
8992 if (
8993 !tolua_isusertype(tolua_S,1,"ImageSlider",0,&tolua_err) ||
8994 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
8995 !tolua_isnoobj(tolua_S,3,&tolua_err)
8996 )
8997 goto tolua_lerror;
8998 else
8999 #endif
9000 {
9001 ImageSlider* self = (ImageSlider*) tolua_tousertype(tolua_S,1,0);
9002 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
9003 #ifndef TOLUA_RELEASE
9004 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMarkerImage'", NULL);
9005 #endif
9006 {
9007 self->setMarkerImage(image);
9008 }
9009 }
9010 return 0;
9011 #ifndef TOLUA_RELEASE
9012 tolua_lerror:
9013 tolua_error(tolua_S,"#ferror in function 'setMarkerImage'.",&tolua_err);
9014 return 0;
9015 #endif
9016 }
9017 #endif //#ifndef TOLUA_DISABLE
9018
9019 /* method: setBackgroundImage of class ImageSlider */
9020 #ifndef TOLUA_DISABLE_tolua_stratagus_ImageSlider_setBackgroundImage00
9021 static int tolua_stratagus_ImageSlider_setBackgroundImage00(lua_State* tolua_S)
9022 {
9023 #ifndef TOLUA_RELEASE
9024 tolua_Error tolua_err;
9025 if (
9026 !tolua_isusertype(tolua_S,1,"ImageSlider",0,&tolua_err) ||
9027 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
9028 !tolua_isnoobj(tolua_S,3,&tolua_err)
9029 )
9030 goto tolua_lerror;
9031 else
9032 #endif
9033 {
9034 ImageSlider* self = (ImageSlider*) tolua_tousertype(tolua_S,1,0);
9035 CGraphic* image = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
9036 #ifndef TOLUA_RELEASE
9037 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundImage'", NULL);
9038 #endif
9039 {
9040 self->setBackgroundImage(image);
9041 }
9042 }
9043 return 0;
9044 #ifndef TOLUA_RELEASE
9045 tolua_lerror:
9046 tolua_error(tolua_S,"#ferror in function 'setBackgroundImage'.",&tolua_err);
9047 return 0;
9048 #endif
9049 }
9050 #endif //#ifndef TOLUA_DISABLE
9051
9052 /* method: new of class Label */
9053 #ifndef TOLUA_DISABLE_tolua_stratagus_Label_new00
9054 static int tolua_stratagus_Label_new00(lua_State* tolua_S)
9055 {
9056 #ifndef TOLUA_RELEASE
9057 tolua_Error tolua_err;
9058 if (
9059 !tolua_isusertable(tolua_S,1,"Label",0,&tolua_err) ||
9060 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
9061 !tolua_isnoobj(tolua_S,3,&tolua_err)
9062 )
9063 goto tolua_lerror;
9064 else
9065 #endif
9066 {
9067 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
9068 {
9069 Label* tolua_ret = (Label*) Mtolua_new((Label)(caption));
9070 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Label");
9071 }
9072 }
9073 return 1;
9074 #ifndef TOLUA_RELEASE
9075 tolua_lerror:
9076 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9077 return 0;
9078 #endif
9079 }
9080 #endif //#ifndef TOLUA_DISABLE
9081
9082 /* method: new_local of class Label */
9083 #ifndef TOLUA_DISABLE_tolua_stratagus_Label_new00_local
9084 static int tolua_stratagus_Label_new00_local(lua_State* tolua_S)
9085 {
9086 #ifndef TOLUA_RELEASE
9087 tolua_Error tolua_err;
9088 if (
9089 !tolua_isusertable(tolua_S,1,"Label",0,&tolua_err) ||
9090 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
9091 !tolua_isnoobj(tolua_S,3,&tolua_err)
9092 )
9093 goto tolua_lerror;
9094 else
9095 #endif
9096 {
9097 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
9098 {
9099 Label* tolua_ret = (Label*) Mtolua_new((Label)(caption));
9100 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Label");
9101 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
9102 }
9103 }
9104 return 1;
9105 #ifndef TOLUA_RELEASE
9106 tolua_lerror:
9107 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9108 return 0;
9109 #endif
9110 }
9111 #endif //#ifndef TOLUA_DISABLE
9112
9113 /* method: getCaption of class Label */
9114 #ifndef TOLUA_DISABLE_tolua_stratagus_Label_getCaption00
9115 static int tolua_stratagus_Label_getCaption00(lua_State* tolua_S)
9116 {
9117 #ifndef TOLUA_RELEASE
9118 tolua_Error tolua_err;
9119 if (
9120 !tolua_isusertype(tolua_S,1,"const Label",0,&tolua_err) ||
9121 !tolua_isnoobj(tolua_S,2,&tolua_err)
9122 )
9123 goto tolua_lerror;
9124 else
9125 #endif
9126 {
9127 const Label* self = (const Label*) tolua_tousertype(tolua_S,1,0);
9128 #ifndef TOLUA_RELEASE
9129 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaption'", NULL);
9130 #endif
9131 {
9132 const std::string tolua_ret = (const std::string) self->getCaption();
9133 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
9134 }
9135 }
9136 return 1;
9137 #ifndef TOLUA_RELEASE
9138 tolua_lerror:
9139 tolua_error(tolua_S,"#ferror in function 'getCaption'.",&tolua_err);
9140 return 0;
9141 #endif
9142 }
9143 #endif //#ifndef TOLUA_DISABLE
9144
9145 /* method: setCaption of class Label */
9146 #ifndef TOLUA_DISABLE_tolua_stratagus_Label_setCaption00
9147 static int tolua_stratagus_Label_setCaption00(lua_State* tolua_S)
9148 {
9149 #ifndef TOLUA_RELEASE
9150 tolua_Error tolua_err;
9151 if (
9152 !tolua_isusertype(tolua_S,1,"Label",0,&tolua_err) ||
9153 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
9154 !tolua_isnoobj(tolua_S,3,&tolua_err)
9155 )
9156 goto tolua_lerror;
9157 else
9158 #endif
9159 {
9160 Label* self = (Label*) tolua_tousertype(tolua_S,1,0);
9161 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
9162 #ifndef TOLUA_RELEASE
9163 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaption'", NULL);
9164 #endif
9165 {
9166 self->setCaption(caption);
9167 }
9168 }
9169 return 0;
9170 #ifndef TOLUA_RELEASE
9171 tolua_lerror:
9172 tolua_error(tolua_S,"#ferror in function 'setCaption'.",&tolua_err);
9173 return 0;
9174 #endif
9175 }
9176 #endif //#ifndef TOLUA_DISABLE
9177
9178 /* method: setAlignment of class Label */
9179 #ifndef TOLUA_DISABLE_tolua_stratagus_Label_setAlignment00
9180 static int tolua_stratagus_Label_setAlignment00(lua_State* tolua_S)
9181 {
9182 #ifndef TOLUA_RELEASE
9183 tolua_Error tolua_err;
9184 if (
9185 !tolua_isusertype(tolua_S,1,"Label",0,&tolua_err) ||
9186 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9187 !tolua_isnoobj(tolua_S,3,&tolua_err)
9188 )
9189 goto tolua_lerror;
9190 else
9191 #endif
9192 {
9193 Label* self = (Label*) tolua_tousertype(tolua_S,1,0);
9194 unsigned int alignment = ((unsigned int) tolua_tonumber(tolua_S,2,0));
9195 #ifndef TOLUA_RELEASE
9196 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlignment'", NULL);
9197 #endif
9198 {
9199 self->setAlignment(alignment);
9200 }
9201 }
9202 return 0;
9203 #ifndef TOLUA_RELEASE
9204 tolua_lerror:
9205 tolua_error(tolua_S,"#ferror in function 'setAlignment'.",&tolua_err);
9206 return 0;
9207 #endif
9208 }
9209 #endif //#ifndef TOLUA_DISABLE
9210
9211 /* method: getAlignment of class Label */
9212 #ifndef TOLUA_DISABLE_tolua_stratagus_Label_getAlignment00
9213 static int tolua_stratagus_Label_getAlignment00(lua_State* tolua_S)
9214 {
9215 #ifndef TOLUA_RELEASE
9216 tolua_Error tolua_err;
9217 if (
9218 !tolua_isusertype(tolua_S,1,"Label",0,&tolua_err) ||
9219 !tolua_isnoobj(tolua_S,2,&tolua_err)
9220 )
9221 goto tolua_lerror;
9222 else
9223 #endif
9224 {
9225 Label* self = (Label*) tolua_tousertype(tolua_S,1,0);
9226 #ifndef TOLUA_RELEASE
9227 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAlignment'", NULL);
9228 #endif
9229 {
9230 unsigned int tolua_ret = (unsigned int) self->getAlignment();
9231 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
9232 }
9233 }
9234 return 1;
9235 #ifndef TOLUA_RELEASE
9236 tolua_lerror:
9237 tolua_error(tolua_S,"#ferror in function 'getAlignment'.",&tolua_err);
9238 return 0;
9239 #endif
9240 }
9241 #endif //#ifndef TOLUA_DISABLE
9242
9243 /* method: adjustSize of class Label */
9244 #ifndef TOLUA_DISABLE_tolua_stratagus_Label_adjustSize00
9245 static int tolua_stratagus_Label_adjustSize00(lua_State* tolua_S)
9246 {
9247 #ifndef TOLUA_RELEASE
9248 tolua_Error tolua_err;
9249 if (
9250 !tolua_isusertype(tolua_S,1,"Label",0,&tolua_err) ||
9251 !tolua_isnoobj(tolua_S,2,&tolua_err)
9252 )
9253 goto tolua_lerror;
9254 else
9255 #endif
9256 {
9257 Label* self = (Label*) tolua_tousertype(tolua_S,1,0);
9258 #ifndef TOLUA_RELEASE
9259 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'adjustSize'", NULL);
9260 #endif
9261 {
9262 self->adjustSize();
9263 }
9264 }
9265 return 0;
9266 #ifndef TOLUA_RELEASE
9267 tolua_lerror:
9268 tolua_error(tolua_S,"#ferror in function 'adjustSize'.",&tolua_err);
9269 return 0;
9270 #endif
9271 }
9272 #endif //#ifndef TOLUA_DISABLE
9273
9274 /* method: new of class MultiLineLabel */
9275 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_new00
9276 static int tolua_stratagus_MultiLineLabel_new00(lua_State* tolua_S)
9277 {
9278 #ifndef TOLUA_RELEASE
9279 tolua_Error tolua_err;
9280 if (
9281 !tolua_isusertable(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9282 !tolua_isnoobj(tolua_S,2,&tolua_err)
9283 )
9284 goto tolua_lerror;
9285 else
9286 #endif
9287 {
9288 {
9289 MultiLineLabel* tolua_ret = (MultiLineLabel*) Mtolua_new((MultiLineLabel)());
9290 tolua_pushusertype(tolua_S,(void*)tolua_ret,"MultiLineLabel");
9291 }
9292 }
9293 return 1;
9294 #ifndef TOLUA_RELEASE
9295 tolua_lerror:
9296 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9297 return 0;
9298 #endif
9299 }
9300 #endif //#ifndef TOLUA_DISABLE
9301
9302 /* method: new_local of class MultiLineLabel */
9303 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_new00_local
9304 static int tolua_stratagus_MultiLineLabel_new00_local(lua_State* tolua_S)
9305 {
9306 #ifndef TOLUA_RELEASE
9307 tolua_Error tolua_err;
9308 if (
9309 !tolua_isusertable(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9310 !tolua_isnoobj(tolua_S,2,&tolua_err)
9311 )
9312 goto tolua_lerror;
9313 else
9314 #endif
9315 {
9316 {
9317 MultiLineLabel* tolua_ret = (MultiLineLabel*) Mtolua_new((MultiLineLabel)());
9318 tolua_pushusertype(tolua_S,(void*)tolua_ret,"MultiLineLabel");
9319 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
9320 }
9321 }
9322 return 1;
9323 #ifndef TOLUA_RELEASE
9324 tolua_lerror:
9325 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9326 return 0;
9327 #endif
9328 }
9329 #endif //#ifndef TOLUA_DISABLE
9330
9331 /* method: new of class MultiLineLabel */
9332 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_new01
9333 static int tolua_stratagus_MultiLineLabel_new01(lua_State* tolua_S)
9334 {
9335 tolua_Error tolua_err;
9336 if (
9337 !tolua_isusertable(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9338 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
9339 !tolua_isnoobj(tolua_S,3,&tolua_err)
9340 )
9341 goto tolua_lerror;
9342 else
9343 {
9344 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
9345 {
9346 MultiLineLabel* tolua_ret = (MultiLineLabel*) Mtolua_new((MultiLineLabel)(caption));
9347 tolua_pushusertype(tolua_S,(void*)tolua_ret,"MultiLineLabel");
9348 }
9349 }
9350 return 1;
9351 tolua_lerror:
9352 return tolua_stratagus_MultiLineLabel_new00(tolua_S);
9353 }
9354 #endif //#ifndef TOLUA_DISABLE
9355
9356 /* method: new_local of class MultiLineLabel */
9357 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_new01_local
9358 static int tolua_stratagus_MultiLineLabel_new01_local(lua_State* tolua_S)
9359 {
9360 tolua_Error tolua_err;
9361 if (
9362 !tolua_isusertable(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9363 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
9364 !tolua_isnoobj(tolua_S,3,&tolua_err)
9365 )
9366 goto tolua_lerror;
9367 else
9368 {
9369 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
9370 {
9371 MultiLineLabel* tolua_ret = (MultiLineLabel*) Mtolua_new((MultiLineLabel)(caption));
9372 tolua_pushusertype(tolua_S,(void*)tolua_ret,"MultiLineLabel");
9373 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
9374 }
9375 }
9376 return 1;
9377 tolua_lerror:
9378 return tolua_stratagus_MultiLineLabel_new00_local(tolua_S);
9379 }
9380 #endif //#ifndef TOLUA_DISABLE
9381
9382 /* method: setCaption of class MultiLineLabel */
9383 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_setCaption00
9384 static int tolua_stratagus_MultiLineLabel_setCaption00(lua_State* tolua_S)
9385 {
9386 #ifndef TOLUA_RELEASE
9387 tolua_Error tolua_err;
9388 if (
9389 !tolua_isusertype(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9390 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
9391 !tolua_isnoobj(tolua_S,3,&tolua_err)
9392 )
9393 goto tolua_lerror;
9394 else
9395 #endif
9396 {
9397 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9398 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
9399 #ifndef TOLUA_RELEASE
9400 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaption'", NULL);
9401 #endif
9402 {
9403 self->setCaption(caption);
9404 }
9405 }
9406 return 0;
9407 #ifndef TOLUA_RELEASE
9408 tolua_lerror:
9409 tolua_error(tolua_S,"#ferror in function 'setCaption'.",&tolua_err);
9410 return 0;
9411 #endif
9412 }
9413 #endif //#ifndef TOLUA_DISABLE
9414
9415 /* method: getCaption of class MultiLineLabel */
9416 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_getCaption00
9417 static int tolua_stratagus_MultiLineLabel_getCaption00(lua_State* tolua_S)
9418 {
9419 #ifndef TOLUA_RELEASE
9420 tolua_Error tolua_err;
9421 if (
9422 !tolua_isusertype(tolua_S,1,"const MultiLineLabel",0,&tolua_err) ||
9423 !tolua_isnoobj(tolua_S,2,&tolua_err)
9424 )
9425 goto tolua_lerror;
9426 else
9427 #endif
9428 {
9429 const MultiLineLabel* self = (const MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9430 #ifndef TOLUA_RELEASE
9431 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaption'", NULL);
9432 #endif
9433 {
9434 const std::string tolua_ret = (const std::string) self->getCaption();
9435 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
9436 }
9437 }
9438 return 1;
9439 #ifndef TOLUA_RELEASE
9440 tolua_lerror:
9441 tolua_error(tolua_S,"#ferror in function 'getCaption'.",&tolua_err);
9442 return 0;
9443 #endif
9444 }
9445 #endif //#ifndef TOLUA_DISABLE
9446
9447 /* method: setAlignment of class MultiLineLabel */
9448 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_setAlignment00
9449 static int tolua_stratagus_MultiLineLabel_setAlignment00(lua_State* tolua_S)
9450 {
9451 #ifndef TOLUA_RELEASE
9452 tolua_Error tolua_err;
9453 if (
9454 !tolua_isusertype(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9455 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9456 !tolua_isnoobj(tolua_S,3,&tolua_err)
9457 )
9458 goto tolua_lerror;
9459 else
9460 #endif
9461 {
9462 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9463 unsigned int alignment = ((unsigned int) tolua_tonumber(tolua_S,2,0));
9464 #ifndef TOLUA_RELEASE
9465 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlignment'", NULL);
9466 #endif
9467 {
9468 self->setAlignment(alignment);
9469 }
9470 }
9471 return 0;
9472 #ifndef TOLUA_RELEASE
9473 tolua_lerror:
9474 tolua_error(tolua_S,"#ferror in function 'setAlignment'.",&tolua_err);
9475 return 0;
9476 #endif
9477 }
9478 #endif //#ifndef TOLUA_DISABLE
9479
9480 /* method: getAlignment of class MultiLineLabel */
9481 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_getAlignment00
9482 static int tolua_stratagus_MultiLineLabel_getAlignment00(lua_State* tolua_S)
9483 {
9484 #ifndef TOLUA_RELEASE
9485 tolua_Error tolua_err;
9486 if (
9487 !tolua_isusertype(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9488 !tolua_isnoobj(tolua_S,2,&tolua_err)
9489 )
9490 goto tolua_lerror;
9491 else
9492 #endif
9493 {
9494 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9495 #ifndef TOLUA_RELEASE
9496 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAlignment'", NULL);
9497 #endif
9498 {
9499 unsigned int tolua_ret = (unsigned int) self->getAlignment();
9500 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
9501 }
9502 }
9503 return 1;
9504 #ifndef TOLUA_RELEASE
9505 tolua_lerror:
9506 tolua_error(tolua_S,"#ferror in function 'getAlignment'.",&tolua_err);
9507 return 0;
9508 #endif
9509 }
9510 #endif //#ifndef TOLUA_DISABLE
9511
9512 /* method: setVerticalAlignment of class MultiLineLabel */
9513 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_setVerticalAlignment00
9514 static int tolua_stratagus_MultiLineLabel_setVerticalAlignment00(lua_State* tolua_S)
9515 {
9516 #ifndef TOLUA_RELEASE
9517 tolua_Error tolua_err;
9518 if (
9519 !tolua_isusertype(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9520 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9521 !tolua_isnoobj(tolua_S,3,&tolua_err)
9522 )
9523 goto tolua_lerror;
9524 else
9525 #endif
9526 {
9527 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9528 unsigned int alignment = ((unsigned int) tolua_tonumber(tolua_S,2,0));
9529 #ifndef TOLUA_RELEASE
9530 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalAlignment'", NULL);
9531 #endif
9532 {
9533 self->setVerticalAlignment(alignment);
9534 }
9535 }
9536 return 0;
9537 #ifndef TOLUA_RELEASE
9538 tolua_lerror:
9539 tolua_error(tolua_S,"#ferror in function 'setVerticalAlignment'.",&tolua_err);
9540 return 0;
9541 #endif
9542 }
9543 #endif //#ifndef TOLUA_DISABLE
9544
9545 /* method: getVerticalAlignment of class MultiLineLabel */
9546 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_getVerticalAlignment00
9547 static int tolua_stratagus_MultiLineLabel_getVerticalAlignment00(lua_State* tolua_S)
9548 {
9549 #ifndef TOLUA_RELEASE
9550 tolua_Error tolua_err;
9551 if (
9552 !tolua_isusertype(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9553 !tolua_isnoobj(tolua_S,2,&tolua_err)
9554 )
9555 goto tolua_lerror;
9556 else
9557 #endif
9558 {
9559 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9560 #ifndef TOLUA_RELEASE
9561 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVerticalAlignment'", NULL);
9562 #endif
9563 {
9564 unsigned int tolua_ret = (unsigned int) self->getVerticalAlignment();
9565 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
9566 }
9567 }
9568 return 1;
9569 #ifndef TOLUA_RELEASE
9570 tolua_lerror:
9571 tolua_error(tolua_S,"#ferror in function 'getVerticalAlignment'.",&tolua_err);
9572 return 0;
9573 #endif
9574 }
9575 #endif //#ifndef TOLUA_DISABLE
9576
9577 /* method: setLineWidth of class MultiLineLabel */
9578 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_setLineWidth00
9579 static int tolua_stratagus_MultiLineLabel_setLineWidth00(lua_State* tolua_S)
9580 {
9581 #ifndef TOLUA_RELEASE
9582 tolua_Error tolua_err;
9583 if (
9584 !tolua_isusertype(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9585 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9586 !tolua_isnoobj(tolua_S,3,&tolua_err)
9587 )
9588 goto tolua_lerror;
9589 else
9590 #endif
9591 {
9592 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9593 int width = ((int) tolua_tonumber(tolua_S,2,0));
9594 #ifndef TOLUA_RELEASE
9595 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setLineWidth'", NULL);
9596 #endif
9597 {
9598 self->setLineWidth(width);
9599 }
9600 }
9601 return 0;
9602 #ifndef TOLUA_RELEASE
9603 tolua_lerror:
9604 tolua_error(tolua_S,"#ferror in function 'setLineWidth'.",&tolua_err);
9605 return 0;
9606 #endif
9607 }
9608 #endif //#ifndef TOLUA_DISABLE
9609
9610 /* method: getLineWidth of class MultiLineLabel */
9611 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_getLineWidth00
9612 static int tolua_stratagus_MultiLineLabel_getLineWidth00(lua_State* tolua_S)
9613 {
9614 #ifndef TOLUA_RELEASE
9615 tolua_Error tolua_err;
9616 if (
9617 !tolua_isusertype(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9618 !tolua_isnoobj(tolua_S,2,&tolua_err)
9619 )
9620 goto tolua_lerror;
9621 else
9622 #endif
9623 {
9624 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9625 #ifndef TOLUA_RELEASE
9626 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLineWidth'", NULL);
9627 #endif
9628 {
9629 int tolua_ret = (int) self->getLineWidth();
9630 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
9631 }
9632 }
9633 return 1;
9634 #ifndef TOLUA_RELEASE
9635 tolua_lerror:
9636 tolua_error(tolua_S,"#ferror in function 'getLineWidth'.",&tolua_err);
9637 return 0;
9638 #endif
9639 }
9640 #endif //#ifndef TOLUA_DISABLE
9641
9642 /* method: adjustSize of class MultiLineLabel */
9643 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_adjustSize00
9644 static int tolua_stratagus_MultiLineLabel_adjustSize00(lua_State* tolua_S)
9645 {
9646 #ifndef TOLUA_RELEASE
9647 tolua_Error tolua_err;
9648 if (
9649 !tolua_isusertype(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9650 !tolua_isnoobj(tolua_S,2,&tolua_err)
9651 )
9652 goto tolua_lerror;
9653 else
9654 #endif
9655 {
9656 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9657 #ifndef TOLUA_RELEASE
9658 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'adjustSize'", NULL);
9659 #endif
9660 {
9661 self->adjustSize();
9662 }
9663 }
9664 return 0;
9665 #ifndef TOLUA_RELEASE
9666 tolua_lerror:
9667 tolua_error(tolua_S,"#ferror in function 'adjustSize'.",&tolua_err);
9668 return 0;
9669 #endif
9670 }
9671 #endif //#ifndef TOLUA_DISABLE
9672
9673 /* method: draw of class MultiLineLabel */
9674 #ifndef TOLUA_DISABLE_tolua_stratagus_MultiLineLabel_draw00
9675 static int tolua_stratagus_MultiLineLabel_draw00(lua_State* tolua_S)
9676 {
9677 #ifndef TOLUA_RELEASE
9678 tolua_Error tolua_err;
9679 if (
9680 !tolua_isusertype(tolua_S,1,"MultiLineLabel",0,&tolua_err) ||
9681 !tolua_isusertype(tolua_S,2,"gcn::Graphics",0,&tolua_err) ||
9682 !tolua_isnoobj(tolua_S,3,&tolua_err)
9683 )
9684 goto tolua_lerror;
9685 else
9686 #endif
9687 {
9688 MultiLineLabel* self = (MultiLineLabel*) tolua_tousertype(tolua_S,1,0);
9689 gcn::Graphics* graphics = ((gcn::Graphics*) tolua_tousertype(tolua_S,2,0));
9690 #ifndef TOLUA_RELEASE
9691 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'draw'", NULL);
9692 #endif
9693 {
9694 self->draw(graphics);
9695 }
9696 }
9697 return 0;
9698 #ifndef TOLUA_RELEASE
9699 tolua_lerror:
9700 tolua_error(tolua_S,"#ferror in function 'draw'.",&tolua_err);
9701 return 0;
9702 #endif
9703 }
9704 #endif //#ifndef TOLUA_DISABLE
9705
9706 /* method: new of class TextField */
9707 #ifndef TOLUA_DISABLE_tolua_stratagus_TextField_new00
9708 static int tolua_stratagus_TextField_new00(lua_State* tolua_S)
9709 {
9710 #ifndef TOLUA_RELEASE
9711 tolua_Error tolua_err;
9712 if (
9713 !tolua_isusertable(tolua_S,1,"TextField",0,&tolua_err) ||
9714 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
9715 !tolua_isnoobj(tolua_S,3,&tolua_err)
9716 )
9717 goto tolua_lerror;
9718 else
9719 #endif
9720 {
9721 const std::string text = ((const std::string) tolua_tocppstring(tolua_S,2,0));
9722 {
9723 TextField* tolua_ret = (TextField*) Mtolua_new((TextField)(text));
9724 tolua_pushusertype(tolua_S,(void*)tolua_ret,"TextField");
9725 }
9726 }
9727 return 1;
9728 #ifndef TOLUA_RELEASE
9729 tolua_lerror:
9730 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9731 return 0;
9732 #endif
9733 }
9734 #endif //#ifndef TOLUA_DISABLE
9735
9736 /* method: new_local of class TextField */
9737 #ifndef TOLUA_DISABLE_tolua_stratagus_TextField_new00_local
9738 static int tolua_stratagus_TextField_new00_local(lua_State* tolua_S)
9739 {
9740 #ifndef TOLUA_RELEASE
9741 tolua_Error tolua_err;
9742 if (
9743 !tolua_isusertable(tolua_S,1,"TextField",0,&tolua_err) ||
9744 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
9745 !tolua_isnoobj(tolua_S,3,&tolua_err)
9746 )
9747 goto tolua_lerror;
9748 else
9749 #endif
9750 {
9751 const std::string text = ((const std::string) tolua_tocppstring(tolua_S,2,0));
9752 {
9753 TextField* tolua_ret = (TextField*) Mtolua_new((TextField)(text));
9754 tolua_pushusertype(tolua_S,(void*)tolua_ret,"TextField");
9755 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
9756 }
9757 }
9758 return 1;
9759 #ifndef TOLUA_RELEASE
9760 tolua_lerror:
9761 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9762 return 0;
9763 #endif
9764 }
9765 #endif //#ifndef TOLUA_DISABLE
9766
9767 /* method: setText of class TextField */
9768 #ifndef TOLUA_DISABLE_tolua_stratagus_TextField_setText00
9769 static int tolua_stratagus_TextField_setText00(lua_State* tolua_S)
9770 {
9771 #ifndef TOLUA_RELEASE
9772 tolua_Error tolua_err;
9773 if (
9774 !tolua_isusertype(tolua_S,1,"TextField",0,&tolua_err) ||
9775 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
9776 !tolua_isnoobj(tolua_S,3,&tolua_err)
9777 )
9778 goto tolua_lerror;
9779 else
9780 #endif
9781 {
9782 TextField* self = (TextField*) tolua_tousertype(tolua_S,1,0);
9783 const std::string text = ((const std::string) tolua_tocppstring(tolua_S,2,0));
9784 #ifndef TOLUA_RELEASE
9785 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setText'", NULL);
9786 #endif
9787 {
9788 self->setText(text);
9789 }
9790 }
9791 return 0;
9792 #ifndef TOLUA_RELEASE
9793 tolua_lerror:
9794 tolua_error(tolua_S,"#ferror in function 'setText'.",&tolua_err);
9795 return 0;
9796 #endif
9797 }
9798 #endif //#ifndef TOLUA_DISABLE
9799
9800 /* method: getText of class TextField */
9801 #ifndef TOLUA_DISABLE_tolua_stratagus_TextField_getText00
9802 static int tolua_stratagus_TextField_getText00(lua_State* tolua_S)
9803 {
9804 #ifndef TOLUA_RELEASE
9805 tolua_Error tolua_err;
9806 if (
9807 !tolua_isusertype(tolua_S,1,"TextField",0,&tolua_err) ||
9808 !tolua_isnoobj(tolua_S,2,&tolua_err)
9809 )
9810 goto tolua_lerror;
9811 else
9812 #endif
9813 {
9814 TextField* self = (TextField*) tolua_tousertype(tolua_S,1,0);
9815 #ifndef TOLUA_RELEASE
9816 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getText'", NULL);
9817 #endif
9818 {
9819 std::string tolua_ret = (std::string) self->getText();
9820 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
9821 }
9822 }
9823 return 1;
9824 #ifndef TOLUA_RELEASE
9825 tolua_lerror:
9826 tolua_error(tolua_S,"#ferror in function 'getText'.",&tolua_err);
9827 return 0;
9828 #endif
9829 }
9830 #endif //#ifndef TOLUA_DISABLE
9831
9832 /* method: setMaxLengthBytes of class TextField */
9833 #ifndef TOLUA_DISABLE_tolua_stratagus_TextField_setMaxLengthBytes00
9834 static int tolua_stratagus_TextField_setMaxLengthBytes00(lua_State* tolua_S)
9835 {
9836 #ifndef TOLUA_RELEASE
9837 tolua_Error tolua_err;
9838 if (
9839 !tolua_isusertype(tolua_S,1,"TextField",0,&tolua_err) ||
9840 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9841 !tolua_isnoobj(tolua_S,3,&tolua_err)
9842 )
9843 goto tolua_lerror;
9844 else
9845 #endif
9846 {
9847 TextField* self = (TextField*) tolua_tousertype(tolua_S,1,0);
9848 int maxLengthBytes = ((int) tolua_tonumber(tolua_S,2,0));
9849 #ifndef TOLUA_RELEASE
9850 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMaxLengthBytes'", NULL);
9851 #endif
9852 {
9853 self->setMaxLengthBytes(maxLengthBytes);
9854 }
9855 }
9856 return 0;
9857 #ifndef TOLUA_RELEASE
9858 tolua_lerror:
9859 tolua_error(tolua_S,"#ferror in function 'setMaxLengthBytes'.",&tolua_err);
9860 return 0;
9861 #endif
9862 }
9863 #endif //#ifndef TOLUA_DISABLE
9864
9865 /* method: getMaxLengthBytes of class TextField */
9866 #ifndef TOLUA_DISABLE_tolua_stratagus_TextField_getMaxLengthBytes00
9867 static int tolua_stratagus_TextField_getMaxLengthBytes00(lua_State* tolua_S)
9868 {
9869 #ifndef TOLUA_RELEASE
9870 tolua_Error tolua_err;
9871 if (
9872 !tolua_isusertype(tolua_S,1,"const TextField",0,&tolua_err) ||
9873 !tolua_isnoobj(tolua_S,2,&tolua_err)
9874 )
9875 goto tolua_lerror;
9876 else
9877 #endif
9878 {
9879 const TextField* self = (const TextField*) tolua_tousertype(tolua_S,1,0);
9880 #ifndef TOLUA_RELEASE
9881 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaxLengthBytes'", NULL);
9882 #endif
9883 {
9884 int tolua_ret = (int) self->getMaxLengthBytes();
9885 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
9886 }
9887 }
9888 return 1;
9889 #ifndef TOLUA_RELEASE
9890 tolua_lerror:
9891 tolua_error(tolua_S,"#ferror in function 'getMaxLengthBytes'.",&tolua_err);
9892 return 0;
9893 #endif
9894 }
9895 #endif //#ifndef TOLUA_DISABLE
9896
9897 /* method: new of class ListBoxWidget */
9898 #ifndef TOLUA_DISABLE_tolua_stratagus_ListBoxWidget_new00
9899 static int tolua_stratagus_ListBoxWidget_new00(lua_State* tolua_S)
9900 {
9901 #ifndef TOLUA_RELEASE
9902 tolua_Error tolua_err;
9903 if (
9904 !tolua_isusertable(tolua_S,1,"ListBoxWidget",0,&tolua_err) ||
9905 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9906 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
9907 !tolua_isnoobj(tolua_S,4,&tolua_err)
9908 )
9909 goto tolua_lerror;
9910 else
9911 #endif
9912 {
9913 unsigned int width = ((unsigned int) tolua_tonumber(tolua_S,2,0));
9914 unsigned int height = ((unsigned int) tolua_tonumber(tolua_S,3,0));
9915 {
9916 ListBoxWidget* tolua_ret = (ListBoxWidget*) Mtolua_new((ListBoxWidget)(width,height));
9917 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ListBoxWidget");
9918 }
9919 }
9920 return 1;
9921 #ifndef TOLUA_RELEASE
9922 tolua_lerror:
9923 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9924 return 0;
9925 #endif
9926 }
9927 #endif //#ifndef TOLUA_DISABLE
9928
9929 /* method: new_local of class ListBoxWidget */
9930 #ifndef TOLUA_DISABLE_tolua_stratagus_ListBoxWidget_new00_local
9931 static int tolua_stratagus_ListBoxWidget_new00_local(lua_State* tolua_S)
9932 {
9933 #ifndef TOLUA_RELEASE
9934 tolua_Error tolua_err;
9935 if (
9936 !tolua_isusertable(tolua_S,1,"ListBoxWidget",0,&tolua_err) ||
9937 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9938 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
9939 !tolua_isnoobj(tolua_S,4,&tolua_err)
9940 )
9941 goto tolua_lerror;
9942 else
9943 #endif
9944 {
9945 unsigned int width = ((unsigned int) tolua_tonumber(tolua_S,2,0));
9946 unsigned int height = ((unsigned int) tolua_tonumber(tolua_S,3,0));
9947 {
9948 ListBoxWidget* tolua_ret = (ListBoxWidget*) Mtolua_new((ListBoxWidget)(width,height));
9949 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ListBoxWidget");
9950 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
9951 }
9952 }
9953 return 1;
9954 #ifndef TOLUA_RELEASE
9955 tolua_lerror:
9956 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9957 return 0;
9958 #endif
9959 }
9960 #endif //#ifndef TOLUA_DISABLE
9961
9962 /* method: setList of class ListBoxWidget */
9963 #ifndef TOLUA_DISABLE_tolua_stratagus_ListBoxWidget_setList00
9964 static int tolua_stratagus_ListBoxWidget_setList00(lua_State* tolua_S)
9965 {
9966 #ifndef TOLUA_RELEASE
9967 tolua_Error tolua_err;
9968 if (
9969 !tolua_isusertype(tolua_S,1,"ListBoxWidget",0,&tolua_err) ||
9970 !tolua_isnoobj(tolua_S,3,&tolua_err)
9971 )
9972 goto tolua_lerror;
9973 else
9974 #endif
9975 {
9976 ListBoxWidget* self = (ListBoxWidget*) tolua_tousertype(tolua_S,1,0);
9977 lua_State* lua = tolua_S;
9978 lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
9979 #ifndef TOLUA_RELEASE
9980 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setList'", NULL);
9981 #endif
9982 {
9983 self->setList(lua,&lo);
9984 tolua_pushvalue(tolua_S,(int)lo);
9985 }
9986 }
9987 return 1;
9988 #ifndef TOLUA_RELEASE
9989 tolua_lerror:
9990 tolua_error(tolua_S,"#ferror in function 'setList'.",&tolua_err);
9991 return 0;
9992 #endif
9993 }
9994 #endif //#ifndef TOLUA_DISABLE
9995
9996 /* method: setSelected of class ListBoxWidget */
9997 #ifndef TOLUA_DISABLE_tolua_stratagus_ListBoxWidget_setSelected00
9998 static int tolua_stratagus_ListBoxWidget_setSelected00(lua_State* tolua_S)
9999 {
10000 #ifndef TOLUA_RELEASE
10001 tolua_Error tolua_err;
10002 if (
10003 !tolua_isusertype(tolua_S,1,"ListBoxWidget",0,&tolua_err) ||
10004 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10005 !tolua_isnoobj(tolua_S,3,&tolua_err)
10006 )
10007 goto tolua_lerror;
10008 else
10009 #endif
10010 {
10011 ListBoxWidget* self = (ListBoxWidget*) tolua_tousertype(tolua_S,1,0);
10012 int selected = ((int) tolua_tonumber(tolua_S,2,0));
10013 #ifndef TOLUA_RELEASE
10014 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelected'", NULL);
10015 #endif
10016 {
10017 self->setSelected(selected);
10018 }
10019 }
10020 return 0;
10021 #ifndef TOLUA_RELEASE
10022 tolua_lerror:
10023 tolua_error(tolua_S,"#ferror in function 'setSelected'.",&tolua_err);
10024 return 0;
10025 #endif
10026 }
10027 #endif //#ifndef TOLUA_DISABLE
10028
10029 /* method: getSelected of class ListBoxWidget */
10030 #ifndef TOLUA_DISABLE_tolua_stratagus_ListBoxWidget_getSelected00
10031 static int tolua_stratagus_ListBoxWidget_getSelected00(lua_State* tolua_S)
10032 {
10033 #ifndef TOLUA_RELEASE
10034 tolua_Error tolua_err;
10035 if (
10036 !tolua_isusertype(tolua_S,1,"ListBoxWidget",0,&tolua_err) ||
10037 !tolua_isnoobj(tolua_S,2,&tolua_err)
10038 )
10039 goto tolua_lerror;
10040 else
10041 #endif
10042 {
10043 ListBoxWidget* self = (ListBoxWidget*) tolua_tousertype(tolua_S,1,0);
10044 #ifndef TOLUA_RELEASE
10045 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelected'", NULL);
10046 #endif
10047 {
10048 int tolua_ret = (int) self->getSelected();
10049 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
10050 }
10051 }
10052 return 1;
10053 #ifndef TOLUA_RELEASE
10054 tolua_lerror:
10055 tolua_error(tolua_S,"#ferror in function 'getSelected'.",&tolua_err);
10056 return 0;
10057 #endif
10058 }
10059 #endif //#ifndef TOLUA_DISABLE
10060
10061 /* method: new of class Window */
10062 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_new00
10063 static int tolua_stratagus_Window_new00(lua_State* tolua_S)
10064 {
10065 #ifndef TOLUA_RELEASE
10066 tolua_Error tolua_err;
10067 if (
10068 !tolua_isusertable(tolua_S,1,"Window",0,&tolua_err) ||
10069 !tolua_isnoobj(tolua_S,2,&tolua_err)
10070 )
10071 goto tolua_lerror;
10072 else
10073 #endif
10074 {
10075 {
10076 Window* tolua_ret = (Window*) Mtolua_new((Window)());
10077 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Window");
10078 }
10079 }
10080 return 1;
10081 #ifndef TOLUA_RELEASE
10082 tolua_lerror:
10083 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
10084 return 0;
10085 #endif
10086 }
10087 #endif //#ifndef TOLUA_DISABLE
10088
10089 /* method: new_local of class Window */
10090 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_new00_local
10091 static int tolua_stratagus_Window_new00_local(lua_State* tolua_S)
10092 {
10093 #ifndef TOLUA_RELEASE
10094 tolua_Error tolua_err;
10095 if (
10096 !tolua_isusertable(tolua_S,1,"Window",0,&tolua_err) ||
10097 !tolua_isnoobj(tolua_S,2,&tolua_err)
10098 )
10099 goto tolua_lerror;
10100 else
10101 #endif
10102 {
10103 {
10104 Window* tolua_ret = (Window*) Mtolua_new((Window)());
10105 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Window");
10106 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
10107 }
10108 }
10109 return 1;
10110 #ifndef TOLUA_RELEASE
10111 tolua_lerror:
10112 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
10113 return 0;
10114 #endif
10115 }
10116 #endif //#ifndef TOLUA_DISABLE
10117
10118 /* method: new of class Window */
10119 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_new01
10120 static int tolua_stratagus_Window_new01(lua_State* tolua_S)
10121 {
10122 tolua_Error tolua_err;
10123 if (
10124 !tolua_isusertable(tolua_S,1,"Window",0,&tolua_err) ||
10125 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
10126 !tolua_isnoobj(tolua_S,3,&tolua_err)
10127 )
10128 goto tolua_lerror;
10129 else
10130 {
10131 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
10132 {
10133 Window* tolua_ret = (Window*) Mtolua_new((Window)(caption));
10134 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Window");
10135 }
10136 }
10137 return 1;
10138 tolua_lerror:
10139 return tolua_stratagus_Window_new00(tolua_S);
10140 }
10141 #endif //#ifndef TOLUA_DISABLE
10142
10143 /* method: new_local of class Window */
10144 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_new01_local
10145 static int tolua_stratagus_Window_new01_local(lua_State* tolua_S)
10146 {
10147 tolua_Error tolua_err;
10148 if (
10149 !tolua_isusertable(tolua_S,1,"Window",0,&tolua_err) ||
10150 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
10151 !tolua_isnoobj(tolua_S,3,&tolua_err)
10152 )
10153 goto tolua_lerror;
10154 else
10155 {
10156 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
10157 {
10158 Window* tolua_ret = (Window*) Mtolua_new((Window)(caption));
10159 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Window");
10160 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
10161 }
10162 }
10163 return 1;
10164 tolua_lerror:
10165 return tolua_stratagus_Window_new00_local(tolua_S);
10166 }
10167 #endif //#ifndef TOLUA_DISABLE
10168
10169 /* method: new of class Window */
10170 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_new02
10171 static int tolua_stratagus_Window_new02(lua_State* tolua_S)
10172 {
10173 tolua_Error tolua_err;
10174 if (
10175 !tolua_isusertable(tolua_S,1,"Window",0,&tolua_err) ||
10176 !tolua_isusertype(tolua_S,2,"Widget",0,&tolua_err) ||
10177 !tolua_iscppstring(tolua_S,3,1,&tolua_err) ||
10178 !tolua_isnoobj(tolua_S,4,&tolua_err)
10179 )
10180 goto tolua_lerror;
10181 else
10182 {
10183 Widget* content = ((Widget*) tolua_tousertype(tolua_S,2,0));
10184 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,3,""));
10185 {
10186 Window* tolua_ret = (Window*) Mtolua_new((Window)(content,caption));
10187 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Window");
10188 }
10189 }
10190 return 1;
10191 tolua_lerror:
10192 return tolua_stratagus_Window_new01(tolua_S);
10193 }
10194 #endif //#ifndef TOLUA_DISABLE
10195
10196 /* method: new_local of class Window */
10197 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_new02_local
10198 static int tolua_stratagus_Window_new02_local(lua_State* tolua_S)
10199 {
10200 tolua_Error tolua_err;
10201 if (
10202 !tolua_isusertable(tolua_S,1,"Window",0,&tolua_err) ||
10203 !tolua_isusertype(tolua_S,2,"Widget",0,&tolua_err) ||
10204 !tolua_iscppstring(tolua_S,3,1,&tolua_err) ||
10205 !tolua_isnoobj(tolua_S,4,&tolua_err)
10206 )
10207 goto tolua_lerror;
10208 else
10209 {
10210 Widget* content = ((Widget*) tolua_tousertype(tolua_S,2,0));
10211 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,3,""));
10212 {
10213 Window* tolua_ret = (Window*) Mtolua_new((Window)(content,caption));
10214 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Window");
10215 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
10216 }
10217 }
10218 return 1;
10219 tolua_lerror:
10220 return tolua_stratagus_Window_new01_local(tolua_S);
10221 }
10222 #endif //#ifndef TOLUA_DISABLE
10223
10224 /* method: setCaption of class Window */
10225 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_setCaption00
10226 static int tolua_stratagus_Window_setCaption00(lua_State* tolua_S)
10227 {
10228 #ifndef TOLUA_RELEASE
10229 tolua_Error tolua_err;
10230 if (
10231 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10232 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
10233 !tolua_isnoobj(tolua_S,3,&tolua_err)
10234 )
10235 goto tolua_lerror;
10236 else
10237 #endif
10238 {
10239 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10240 const std::string caption = ((const std::string) tolua_tocppstring(tolua_S,2,0));
10241 #ifndef TOLUA_RELEASE
10242 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaption'", NULL);
10243 #endif
10244 {
10245 self->setCaption(caption);
10246 }
10247 }
10248 return 0;
10249 #ifndef TOLUA_RELEASE
10250 tolua_lerror:
10251 tolua_error(tolua_S,"#ferror in function 'setCaption'.",&tolua_err);
10252 return 0;
10253 #endif
10254 }
10255 #endif //#ifndef TOLUA_DISABLE
10256
10257 /* method: getCaption of class Window */
10258 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_getCaption00
10259 static int tolua_stratagus_Window_getCaption00(lua_State* tolua_S)
10260 {
10261 #ifndef TOLUA_RELEASE
10262 tolua_Error tolua_err;
10263 if (
10264 !tolua_isusertype(tolua_S,1,"const Window",0,&tolua_err) ||
10265 !tolua_isnoobj(tolua_S,2,&tolua_err)
10266 )
10267 goto tolua_lerror;
10268 else
10269 #endif
10270 {
10271 const Window* self = (const Window*) tolua_tousertype(tolua_S,1,0);
10272 #ifndef TOLUA_RELEASE
10273 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaption'", NULL);
10274 #endif
10275 {
10276 const std::string tolua_ret = (const std::string) self->getCaption();
10277 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
10278 }
10279 }
10280 return 1;
10281 #ifndef TOLUA_RELEASE
10282 tolua_lerror:
10283 tolua_error(tolua_S,"#ferror in function 'getCaption'.",&tolua_err);
10284 return 0;
10285 #endif
10286 }
10287 #endif //#ifndef TOLUA_DISABLE
10288
10289 /* method: setAlignment of class Window */
10290 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_setAlignment00
10291 static int tolua_stratagus_Window_setAlignment00(lua_State* tolua_S)
10292 {
10293 #ifndef TOLUA_RELEASE
10294 tolua_Error tolua_err;
10295 if (
10296 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10297 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10298 !tolua_isnoobj(tolua_S,3,&tolua_err)
10299 )
10300 goto tolua_lerror;
10301 else
10302 #endif
10303 {
10304 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10305 unsigned int alignment = ((unsigned int) tolua_tonumber(tolua_S,2,0));
10306 #ifndef TOLUA_RELEASE
10307 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlignment'", NULL);
10308 #endif
10309 {
10310 self->setAlignment(alignment);
10311 }
10312 }
10313 return 0;
10314 #ifndef TOLUA_RELEASE
10315 tolua_lerror:
10316 tolua_error(tolua_S,"#ferror in function 'setAlignment'.",&tolua_err);
10317 return 0;
10318 #endif
10319 }
10320 #endif //#ifndef TOLUA_DISABLE
10321
10322 /* method: getAlignment of class Window */
10323 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_getAlignment00
10324 static int tolua_stratagus_Window_getAlignment00(lua_State* tolua_S)
10325 {
10326 #ifndef TOLUA_RELEASE
10327 tolua_Error tolua_err;
10328 if (
10329 !tolua_isusertype(tolua_S,1,"const Window",0,&tolua_err) ||
10330 !tolua_isnoobj(tolua_S,2,&tolua_err)
10331 )
10332 goto tolua_lerror;
10333 else
10334 #endif
10335 {
10336 const Window* self = (const Window*) tolua_tousertype(tolua_S,1,0);
10337 #ifndef TOLUA_RELEASE
10338 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAlignment'", NULL);
10339 #endif
10340 {
10341 unsigned int tolua_ret = (unsigned int) self->getAlignment();
10342 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
10343 }
10344 }
10345 return 1;
10346 #ifndef TOLUA_RELEASE
10347 tolua_lerror:
10348 tolua_error(tolua_S,"#ferror in function 'getAlignment'.",&tolua_err);
10349 return 0;
10350 #endif
10351 }
10352 #endif //#ifndef TOLUA_DISABLE
10353
10354 /* method: setContent of class Window */
10355 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_setContent00
10356 static int tolua_stratagus_Window_setContent00(lua_State* tolua_S)
10357 {
10358 #ifndef TOLUA_RELEASE
10359 tolua_Error tolua_err;
10360 if (
10361 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10362 !tolua_isusertype(tolua_S,2,"Widget",0,&tolua_err) ||
10363 !tolua_isnoobj(tolua_S,3,&tolua_err)
10364 )
10365 goto tolua_lerror;
10366 else
10367 #endif
10368 {
10369 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10370 Widget* widget = ((Widget*) tolua_tousertype(tolua_S,2,0));
10371 #ifndef TOLUA_RELEASE
10372 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setContent'", NULL);
10373 #endif
10374 {
10375 self->setContent(widget);
10376 }
10377 }
10378 return 0;
10379 #ifndef TOLUA_RELEASE
10380 tolua_lerror:
10381 tolua_error(tolua_S,"#ferror in function 'setContent'.",&tolua_err);
10382 return 0;
10383 #endif
10384 }
10385 #endif //#ifndef TOLUA_DISABLE
10386
10387 /* method: getContent of class Window */
10388 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_getContent00
10389 static int tolua_stratagus_Window_getContent00(lua_State* tolua_S)
10390 {
10391 #ifndef TOLUA_RELEASE
10392 tolua_Error tolua_err;
10393 if (
10394 !tolua_isusertype(tolua_S,1,"const Window",0,&tolua_err) ||
10395 !tolua_isnoobj(tolua_S,2,&tolua_err)
10396 )
10397 goto tolua_lerror;
10398 else
10399 #endif
10400 {
10401 const Window* self = (const Window*) tolua_tousertype(tolua_S,1,0);
10402 #ifndef TOLUA_RELEASE
10403 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getContent'", NULL);
10404 #endif
10405 {
10406 Widget* tolua_ret = (Widget*) self->getContent();
10407 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Widget");
10408 }
10409 }
10410 return 1;
10411 #ifndef TOLUA_RELEASE
10412 tolua_lerror:
10413 tolua_error(tolua_S,"#ferror in function 'getContent'.",&tolua_err);
10414 return 0;
10415 #endif
10416 }
10417 #endif //#ifndef TOLUA_DISABLE
10418
10419 /* method: setPadding of class Window */
10420 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_setPadding00
10421 static int tolua_stratagus_Window_setPadding00(lua_State* tolua_S)
10422 {
10423 #ifndef TOLUA_RELEASE
10424 tolua_Error tolua_err;
10425 if (
10426 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10427 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10428 !tolua_isnoobj(tolua_S,3,&tolua_err)
10429 )
10430 goto tolua_lerror;
10431 else
10432 #endif
10433 {
10434 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10435 unsigned int padding = ((unsigned int) tolua_tonumber(tolua_S,2,0));
10436 #ifndef TOLUA_RELEASE
10437 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPadding'", NULL);
10438 #endif
10439 {
10440 self->setPadding(padding);
10441 }
10442 }
10443 return 0;
10444 #ifndef TOLUA_RELEASE
10445 tolua_lerror:
10446 tolua_error(tolua_S,"#ferror in function 'setPadding'.",&tolua_err);
10447 return 0;
10448 #endif
10449 }
10450 #endif //#ifndef TOLUA_DISABLE
10451
10452 /* method: getPadding of class Window */
10453 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_getPadding00
10454 static int tolua_stratagus_Window_getPadding00(lua_State* tolua_S)
10455 {
10456 #ifndef TOLUA_RELEASE
10457 tolua_Error tolua_err;
10458 if (
10459 !tolua_isusertype(tolua_S,1,"const Window",0,&tolua_err) ||
10460 !tolua_isnoobj(tolua_S,2,&tolua_err)
10461 )
10462 goto tolua_lerror;
10463 else
10464 #endif
10465 {
10466 const Window* self = (const Window*) tolua_tousertype(tolua_S,1,0);
10467 #ifndef TOLUA_RELEASE
10468 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPadding'", NULL);
10469 #endif
10470 {
10471 unsigned int tolua_ret = (unsigned int) self->getPadding();
10472 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
10473 }
10474 }
10475 return 1;
10476 #ifndef TOLUA_RELEASE
10477 tolua_lerror:
10478 tolua_error(tolua_S,"#ferror in function 'getPadding'.",&tolua_err);
10479 return 0;
10480 #endif
10481 }
10482 #endif //#ifndef TOLUA_DISABLE
10483
10484 /* method: setTitleBarHeight of class Window */
10485 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_setTitleBarHeight00
10486 static int tolua_stratagus_Window_setTitleBarHeight00(lua_State* tolua_S)
10487 {
10488 #ifndef TOLUA_RELEASE
10489 tolua_Error tolua_err;
10490 if (
10491 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10492 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10493 !tolua_isnoobj(tolua_S,3,&tolua_err)
10494 )
10495 goto tolua_lerror;
10496 else
10497 #endif
10498 {
10499 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10500 unsigned int height = ((unsigned int) tolua_tonumber(tolua_S,2,0));
10501 #ifndef TOLUA_RELEASE
10502 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTitleBarHeight'", NULL);
10503 #endif
10504 {
10505 self->setTitleBarHeight(height);
10506 }
10507 }
10508 return 0;
10509 #ifndef TOLUA_RELEASE
10510 tolua_lerror:
10511 tolua_error(tolua_S,"#ferror in function 'setTitleBarHeight'.",&tolua_err);
10512 return 0;
10513 #endif
10514 }
10515 #endif //#ifndef TOLUA_DISABLE
10516
10517 /* method: getTitleBarHeight of class Window */
10518 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_getTitleBarHeight00
10519 static int tolua_stratagus_Window_getTitleBarHeight00(lua_State* tolua_S)
10520 {
10521 #ifndef TOLUA_RELEASE
10522 tolua_Error tolua_err;
10523 if (
10524 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10525 !tolua_isnoobj(tolua_S,2,&tolua_err)
10526 )
10527 goto tolua_lerror;
10528 else
10529 #endif
10530 {
10531 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10532 #ifndef TOLUA_RELEASE
10533 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTitleBarHeight'", NULL);
10534 #endif
10535 {
10536 unsigned int tolua_ret = (unsigned int) self->getTitleBarHeight();
10537 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
10538 }
10539 }
10540 return 1;
10541 #ifndef TOLUA_RELEASE
10542 tolua_lerror:
10543 tolua_error(tolua_S,"#ferror in function 'getTitleBarHeight'.",&tolua_err);
10544 return 0;
10545 #endif
10546 }
10547 #endif //#ifndef TOLUA_DISABLE
10548
10549 /* method: setMovable of class Window */
10550 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_setMovable00
10551 static int tolua_stratagus_Window_setMovable00(lua_State* tolua_S)
10552 {
10553 #ifndef TOLUA_RELEASE
10554 tolua_Error tolua_err;
10555 if (
10556 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10557 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
10558 !tolua_isnoobj(tolua_S,3,&tolua_err)
10559 )
10560 goto tolua_lerror;
10561 else
10562 #endif
10563 {
10564 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10565 bool movable = ((bool) tolua_toboolean(tolua_S,2,0));
10566 #ifndef TOLUA_RELEASE
10567 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMovable'", NULL);
10568 #endif
10569 {
10570 self->setMovable(movable);
10571 }
10572 }
10573 return 0;
10574 #ifndef TOLUA_RELEASE
10575 tolua_lerror:
10576 tolua_error(tolua_S,"#ferror in function 'setMovable'.",&tolua_err);
10577 return 0;
10578 #endif
10579 }
10580 #endif //#ifndef TOLUA_DISABLE
10581
10582 /* method: isMovable of class Window */
10583 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_isMovable00
10584 static int tolua_stratagus_Window_isMovable00(lua_State* tolua_S)
10585 {
10586 #ifndef TOLUA_RELEASE
10587 tolua_Error tolua_err;
10588 if (
10589 !tolua_isusertype(tolua_S,1,"const Window",0,&tolua_err) ||
10590 !tolua_isnoobj(tolua_S,2,&tolua_err)
10591 )
10592 goto tolua_lerror;
10593 else
10594 #endif
10595 {
10596 const Window* self = (const Window*) tolua_tousertype(tolua_S,1,0);
10597 #ifndef TOLUA_RELEASE
10598 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isMovable'", NULL);
10599 #endif
10600 {
10601 bool tolua_ret = (bool) self->isMovable();
10602 tolua_pushboolean(tolua_S,(bool)tolua_ret);
10603 }
10604 }
10605 return 1;
10606 #ifndef TOLUA_RELEASE
10607 tolua_lerror:
10608 tolua_error(tolua_S,"#ferror in function 'isMovable'.",&tolua_err);
10609 return 0;
10610 #endif
10611 }
10612 #endif //#ifndef TOLUA_DISABLE
10613
10614 /* method: resizeToContent of class Window */
10615 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_resizeToContent00
10616 static int tolua_stratagus_Window_resizeToContent00(lua_State* tolua_S)
10617 {
10618 #ifndef TOLUA_RELEASE
10619 tolua_Error tolua_err;
10620 if (
10621 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10622 !tolua_isnoobj(tolua_S,2,&tolua_err)
10623 )
10624 goto tolua_lerror;
10625 else
10626 #endif
10627 {
10628 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10629 #ifndef TOLUA_RELEASE
10630 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resizeToContent'", NULL);
10631 #endif
10632 {
10633 self->resizeToContent();
10634 }
10635 }
10636 return 0;
10637 #ifndef TOLUA_RELEASE
10638 tolua_lerror:
10639 tolua_error(tolua_S,"#ferror in function 'resizeToContent'.",&tolua_err);
10640 return 0;
10641 #endif
10642 }
10643 #endif //#ifndef TOLUA_DISABLE
10644
10645 /* method: setOpaque of class Window */
10646 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_setOpaque00
10647 static int tolua_stratagus_Window_setOpaque00(lua_State* tolua_S)
10648 {
10649 #ifndef TOLUA_RELEASE
10650 tolua_Error tolua_err;
10651 if (
10652 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10653 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
10654 !tolua_isnoobj(tolua_S,3,&tolua_err)
10655 )
10656 goto tolua_lerror;
10657 else
10658 #endif
10659 {
10660 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10661 bool opaque = ((bool) tolua_toboolean(tolua_S,2,0));
10662 #ifndef TOLUA_RELEASE
10663 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOpaque'", NULL);
10664 #endif
10665 {
10666 self->setOpaque(opaque);
10667 }
10668 }
10669 return 0;
10670 #ifndef TOLUA_RELEASE
10671 tolua_lerror:
10672 tolua_error(tolua_S,"#ferror in function 'setOpaque'.",&tolua_err);
10673 return 0;
10674 #endif
10675 }
10676 #endif //#ifndef TOLUA_DISABLE
10677
10678 /* method: isOpaque of class Window */
10679 #ifndef TOLUA_DISABLE_tolua_stratagus_Window_isOpaque00
10680 static int tolua_stratagus_Window_isOpaque00(lua_State* tolua_S)
10681 {
10682 #ifndef TOLUA_RELEASE
10683 tolua_Error tolua_err;
10684 if (
10685 !tolua_isusertype(tolua_S,1,"Window",0,&tolua_err) ||
10686 !tolua_isnoobj(tolua_S,2,&tolua_err)
10687 )
10688 goto tolua_lerror;
10689 else
10690 #endif
10691 {
10692 Window* self = (Window*) tolua_tousertype(tolua_S,1,0);
10693 #ifndef TOLUA_RELEASE
10694 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isOpaque'", NULL);
10695 #endif
10696 {
10697 bool tolua_ret = (bool) self->isOpaque();
10698 tolua_pushboolean(tolua_S,(bool)tolua_ret);
10699 }
10700 }
10701 return 1;
10702 #ifndef TOLUA_RELEASE
10703 tolua_lerror:
10704 tolua_error(tolua_S,"#ferror in function 'isOpaque'.",&tolua_err);
10705 return 0;
10706 #endif
10707 }
10708 #endif //#ifndef TOLUA_DISABLE
10709
10710 /* method: new of class Windows */
10711 #ifndef TOLUA_DISABLE_tolua_stratagus_Windows_new00
10712 static int tolua_stratagus_Windows_new00(lua_State* tolua_S)
10713 {
10714 #ifndef TOLUA_RELEASE
10715 tolua_Error tolua_err;
10716 if (
10717 !tolua_isusertable(tolua_S,1,"Windows",0,&tolua_err) ||
10718 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
10719 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
10720 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
10721 !tolua_isnoobj(tolua_S,5,&tolua_err)
10722 )
10723 goto tolua_lerror;
10724 else
10725 #endif
10726 {
10727 const std::string text = ((const std::string) tolua_tocppstring(tolua_S,2,0));
10728 int width = ((int) tolua_tonumber(tolua_S,3,0));
10729 int height = ((int) tolua_tonumber(tolua_S,4,0));
10730 {
10731 Windows* tolua_ret = (Windows*) Mtolua_new((Windows)(text,width,height));
10732 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Windows");
10733 }
10734 }
10735 return 1;
10736 #ifndef TOLUA_RELEASE
10737 tolua_lerror:
10738 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
10739 return 0;
10740 #endif
10741 }
10742 #endif //#ifndef TOLUA_DISABLE
10743
10744 /* method: new_local of class Windows */
10745 #ifndef TOLUA_DISABLE_tolua_stratagus_Windows_new00_local
10746 static int tolua_stratagus_Windows_new00_local(lua_State* tolua_S)
10747 {
10748 #ifndef TOLUA_RELEASE
10749 tolua_Error tolua_err;
10750 if (
10751 !tolua_isusertable(tolua_S,1,"Windows",0,&tolua_err) ||
10752 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
10753 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
10754 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
10755 !tolua_isnoobj(tolua_S,5,&tolua_err)
10756 )
10757 goto tolua_lerror;
10758 else
10759 #endif
10760 {
10761 const std::string text = ((const std::string) tolua_tocppstring(tolua_S,2,0));
10762 int width = ((int) tolua_tonumber(tolua_S,3,0));
10763 int height = ((int) tolua_tonumber(tolua_S,4,0));
10764 {
10765 Windows* tolua_ret = (Windows*) Mtolua_new((Windows)(text,width,height));
10766 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Windows");
10767 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
10768 }
10769 }
10770 return 1;
10771 #ifndef TOLUA_RELEASE
10772 tolua_lerror:
10773 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
10774 return 0;
10775 #endif
10776 }
10777 #endif //#ifndef TOLUA_DISABLE
10778
10779 /* method: add of class Windows */
10780 #ifndef TOLUA_DISABLE_tolua_stratagus_Windows_add00
10781 static int tolua_stratagus_Windows_add00(lua_State* tolua_S)
10782 {
10783 #ifndef TOLUA_RELEASE
10784 tolua_Error tolua_err;
10785 if (
10786 !tolua_isusertype(tolua_S,1,"Windows",0,&tolua_err) ||
10787 !tolua_isusertype(tolua_S,2,"Widget",0,&tolua_err) ||
10788 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
10789 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
10790 !tolua_isnoobj(tolua_S,5,&tolua_err)
10791 )
10792 goto tolua_lerror;
10793 else
10794 #endif
10795 {
10796 Windows* self = (Windows*) tolua_tousertype(tolua_S,1,0);
10797 Widget* widget = ((Widget*) tolua_tousertype(tolua_S,2,0));
10798 int x = ((int) tolua_tonumber(tolua_S,3,0));
10799 int y = ((int) tolua_tonumber(tolua_S,4,0));
10800 #ifndef TOLUA_RELEASE
10801 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'", NULL);
10802 #endif
10803 {
10804 self->add(widget,x,y);
10805 }
10806 }
10807 return 0;
10808 #ifndef TOLUA_RELEASE
10809 tolua_lerror:
10810 tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
10811 return 0;
10812 #endif
10813 }
10814 #endif //#ifndef TOLUA_DISABLE
10815
10816 /* method: new of class ScrollingWidget */
10817 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollingWidget_new00
10818 static int tolua_stratagus_ScrollingWidget_new00(lua_State* tolua_S)
10819 {
10820 #ifndef TOLUA_RELEASE
10821 tolua_Error tolua_err;
10822 if (
10823 !tolua_isusertable(tolua_S,1,"ScrollingWidget",0,&tolua_err) ||
10824 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10825 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
10826 !tolua_isnoobj(tolua_S,4,&tolua_err)
10827 )
10828 goto tolua_lerror;
10829 else
10830 #endif
10831 {
10832 int width = ((int) tolua_tonumber(tolua_S,2,0));
10833 int height = ((int) tolua_tonumber(tolua_S,3,0));
10834 {
10835 ScrollingWidget* tolua_ret = (ScrollingWidget*) Mtolua_new((ScrollingWidget)(width,height));
10836 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ScrollingWidget");
10837 }
10838 }
10839 return 1;
10840 #ifndef TOLUA_RELEASE
10841 tolua_lerror:
10842 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
10843 return 0;
10844 #endif
10845 }
10846 #endif //#ifndef TOLUA_DISABLE
10847
10848 /* method: new_local of class ScrollingWidget */
10849 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollingWidget_new00_local
10850 static int tolua_stratagus_ScrollingWidget_new00_local(lua_State* tolua_S)
10851 {
10852 #ifndef TOLUA_RELEASE
10853 tolua_Error tolua_err;
10854 if (
10855 !tolua_isusertable(tolua_S,1,"ScrollingWidget",0,&tolua_err) ||
10856 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10857 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
10858 !tolua_isnoobj(tolua_S,4,&tolua_err)
10859 )
10860 goto tolua_lerror;
10861 else
10862 #endif
10863 {
10864 int width = ((int) tolua_tonumber(tolua_S,2,0));
10865 int height = ((int) tolua_tonumber(tolua_S,3,0));
10866 {
10867 ScrollingWidget* tolua_ret = (ScrollingWidget*) Mtolua_new((ScrollingWidget)(width,height));
10868 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ScrollingWidget");
10869 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
10870 }
10871 }
10872 return 1;
10873 #ifndef TOLUA_RELEASE
10874 tolua_lerror:
10875 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
10876 return 0;
10877 #endif
10878 }
10879 #endif //#ifndef TOLUA_DISABLE
10880
10881 /* method: add of class ScrollingWidget */
10882 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollingWidget_add00
10883 static int tolua_stratagus_ScrollingWidget_add00(lua_State* tolua_S)
10884 {
10885 #ifndef TOLUA_RELEASE
10886 tolua_Error tolua_err;
10887 if (
10888 !tolua_isusertype(tolua_S,1,"ScrollingWidget",0,&tolua_err) ||
10889 !tolua_isusertype(tolua_S,2,"Widget",0,&tolua_err) ||
10890 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
10891 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
10892 !tolua_isnoobj(tolua_S,5,&tolua_err)
10893 )
10894 goto tolua_lerror;
10895 else
10896 #endif
10897 {
10898 ScrollingWidget* self = (ScrollingWidget*) tolua_tousertype(tolua_S,1,0);
10899 Widget* widget = ((Widget*) tolua_tousertype(tolua_S,2,0));
10900 int x = ((int) tolua_tonumber(tolua_S,3,0));
10901 int y = ((int) tolua_tonumber(tolua_S,4,0));
10902 #ifndef TOLUA_RELEASE
10903 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'", NULL);
10904 #endif
10905 {
10906 self->add(widget,x,y);
10907 }
10908 }
10909 return 0;
10910 #ifndef TOLUA_RELEASE
10911 tolua_lerror:
10912 tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
10913 return 0;
10914 #endif
10915 }
10916 #endif //#ifndef TOLUA_DISABLE
10917
10918 /* method: restart of class ScrollingWidget */
10919 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollingWidget_restart00
10920 static int tolua_stratagus_ScrollingWidget_restart00(lua_State* tolua_S)
10921 {
10922 #ifndef TOLUA_RELEASE
10923 tolua_Error tolua_err;
10924 if (
10925 !tolua_isusertype(tolua_S,1,"ScrollingWidget",0,&tolua_err) ||
10926 !tolua_isnoobj(tolua_S,2,&tolua_err)
10927 )
10928 goto tolua_lerror;
10929 else
10930 #endif
10931 {
10932 ScrollingWidget* self = (ScrollingWidget*) tolua_tousertype(tolua_S,1,0);
10933 #ifndef TOLUA_RELEASE
10934 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'restart'", NULL);
10935 #endif
10936 {
10937 self->restart();
10938 }
10939 }
10940 return 0;
10941 #ifndef TOLUA_RELEASE
10942 tolua_lerror:
10943 tolua_error(tolua_S,"#ferror in function 'restart'.",&tolua_err);
10944 return 0;
10945 #endif
10946 }
10947 #endif //#ifndef TOLUA_DISABLE
10948
10949 /* method: setSpeed of class ScrollingWidget */
10950 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollingWidget_setSpeed00
10951 static int tolua_stratagus_ScrollingWidget_setSpeed00(lua_State* tolua_S)
10952 {
10953 #ifndef TOLUA_RELEASE
10954 tolua_Error tolua_err;
10955 if (
10956 !tolua_isusertype(tolua_S,1,"ScrollingWidget",0,&tolua_err) ||
10957 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10958 !tolua_isnoobj(tolua_S,3,&tolua_err)
10959 )
10960 goto tolua_lerror;
10961 else
10962 #endif
10963 {
10964 ScrollingWidget* self = (ScrollingWidget*) tolua_tousertype(tolua_S,1,0);
10965 float speed = ((float) tolua_tonumber(tolua_S,2,0));
10966 #ifndef TOLUA_RELEASE
10967 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSpeed'", NULL);
10968 #endif
10969 {
10970 self->setSpeed(speed);
10971 }
10972 }
10973 return 0;
10974 #ifndef TOLUA_RELEASE
10975 tolua_lerror:
10976 tolua_error(tolua_S,"#ferror in function 'setSpeed'.",&tolua_err);
10977 return 0;
10978 #endif
10979 }
10980 #endif //#ifndef TOLUA_DISABLE
10981
10982 /* method: getSpeed of class ScrollingWidget */
10983 #ifndef TOLUA_DISABLE_tolua_stratagus_ScrollingWidget_getSpeed00
10984 static int tolua_stratagus_ScrollingWidget_getSpeed00(lua_State* tolua_S)
10985 {
10986 #ifndef TOLUA_RELEASE
10987 tolua_Error tolua_err;
10988 if (
10989 !tolua_isusertype(tolua_S,1,"ScrollingWidget",0,&tolua_err) ||
10990 !tolua_isnoobj(tolua_S,2,&tolua_err)
10991 )
10992 goto tolua_lerror;
10993 else
10994 #endif
10995 {
10996 ScrollingWidget* self = (ScrollingWidget*) tolua_tousertype(tolua_S,1,0);
10997 #ifndef TOLUA_RELEASE
10998 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSpeed'", NULL);
10999 #endif
11000 {
11001 float tolua_ret = (float) self->getSpeed();
11002 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
11003 }
11004 }
11005 return 1;
11006 #ifndef TOLUA_RELEASE
11007 tolua_lerror:
11008 tolua_error(tolua_S,"#ferror in function 'getSpeed'.",&tolua_err);
11009 return 0;
11010 #endif
11011 }
11012 #endif //#ifndef TOLUA_DISABLE
11013
11014 /* method: getSelected of class DropDown */
11015 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDown_getSelected00
11016 static int tolua_stratagus_DropDown_getSelected00(lua_State* tolua_S)
11017 {
11018 #ifndef TOLUA_RELEASE
11019 tolua_Error tolua_err;
11020 if (
11021 !tolua_isusertype(tolua_S,1,"DropDown",0,&tolua_err) ||
11022 !tolua_isnoobj(tolua_S,2,&tolua_err)
11023 )
11024 goto tolua_lerror;
11025 else
11026 #endif
11027 {
11028 DropDown* self = (DropDown*) tolua_tousertype(tolua_S,1,0);
11029 #ifndef TOLUA_RELEASE
11030 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelected'", NULL);
11031 #endif
11032 {
11033 int tolua_ret = (int) self->getSelected();
11034 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
11035 }
11036 }
11037 return 1;
11038 #ifndef TOLUA_RELEASE
11039 tolua_lerror:
11040 tolua_error(tolua_S,"#ferror in function 'getSelected'.",&tolua_err);
11041 return 0;
11042 #endif
11043 }
11044 #endif //#ifndef TOLUA_DISABLE
11045
11046 /* method: setSelected of class DropDown */
11047 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDown_setSelected00
11048 static int tolua_stratagus_DropDown_setSelected00(lua_State* tolua_S)
11049 {
11050 #ifndef TOLUA_RELEASE
11051 tolua_Error tolua_err;
11052 if (
11053 !tolua_isusertype(tolua_S,1,"DropDown",0,&tolua_err) ||
11054 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
11055 !tolua_isnoobj(tolua_S,3,&tolua_err)
11056 )
11057 goto tolua_lerror;
11058 else
11059 #endif
11060 {
11061 DropDown* self = (DropDown*) tolua_tousertype(tolua_S,1,0);
11062 int selected = ((int) tolua_tonumber(tolua_S,2,0));
11063 #ifndef TOLUA_RELEASE
11064 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelected'", NULL);
11065 #endif
11066 {
11067 self->setSelected(selected);
11068 }
11069 }
11070 return 0;
11071 #ifndef TOLUA_RELEASE
11072 tolua_lerror:
11073 tolua_error(tolua_S,"#ferror in function 'setSelected'.",&tolua_err);
11074 return 0;
11075 #endif
11076 }
11077 #endif //#ifndef TOLUA_DISABLE
11078
11079 /* method: setScrollArea of class DropDown */
11080 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDown_setScrollArea00
11081 static int tolua_stratagus_DropDown_setScrollArea00(lua_State* tolua_S)
11082 {
11083 #ifndef TOLUA_RELEASE
11084 tolua_Error tolua_err;
11085 if (
11086 !tolua_isusertype(tolua_S,1,"DropDown",0,&tolua_err) ||
11087 !tolua_isusertype(tolua_S,2,"ScrollArea",0,&tolua_err) ||
11088 !tolua_isnoobj(tolua_S,3,&tolua_err)
11089 )
11090 goto tolua_lerror;
11091 else
11092 #endif
11093 {
11094 DropDown* self = (DropDown*) tolua_tousertype(tolua_S,1,0);
11095 ScrollArea* scrollArea = ((ScrollArea*) tolua_tousertype(tolua_S,2,0));
11096 #ifndef TOLUA_RELEASE
11097 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setScrollArea'", NULL);
11098 #endif
11099 {
11100 self->setScrollArea(scrollArea);
11101 }
11102 }
11103 return 0;
11104 #ifndef TOLUA_RELEASE
11105 tolua_lerror:
11106 tolua_error(tolua_S,"#ferror in function 'setScrollArea'.",&tolua_err);
11107 return 0;
11108 #endif
11109 }
11110 #endif //#ifndef TOLUA_DISABLE
11111
11112 /* method: getScrollArea of class DropDown */
11113 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDown_getScrollArea00
11114 static int tolua_stratagus_DropDown_getScrollArea00(lua_State* tolua_S)
11115 {
11116 #ifndef TOLUA_RELEASE
11117 tolua_Error tolua_err;
11118 if (
11119 !tolua_isusertype(tolua_S,1,"DropDown",0,&tolua_err) ||
11120 !tolua_isnoobj(tolua_S,2,&tolua_err)
11121 )
11122 goto tolua_lerror;
11123 else
11124 #endif
11125 {
11126 DropDown* self = (DropDown*) tolua_tousertype(tolua_S,1,0);
11127 #ifndef TOLUA_RELEASE
11128 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScrollArea'", NULL);
11129 #endif
11130 {
11131 ScrollArea* tolua_ret = (ScrollArea*) self->getScrollArea();
11132 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ScrollArea");
11133 }
11134 }
11135 return 1;
11136 #ifndef TOLUA_RELEASE
11137 tolua_lerror:
11138 tolua_error(tolua_S,"#ferror in function 'getScrollArea'.",&tolua_err);
11139 return 0;
11140 #endif
11141 }
11142 #endif //#ifndef TOLUA_DISABLE
11143
11144 /* method: setListBox of class DropDown */
11145 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDown_setListBox00
11146 static int tolua_stratagus_DropDown_setListBox00(lua_State* tolua_S)
11147 {
11148 #ifndef TOLUA_RELEASE
11149 tolua_Error tolua_err;
11150 if (
11151 !tolua_isusertype(tolua_S,1,"DropDown",0,&tolua_err) ||
11152 !tolua_isusertype(tolua_S,2,"ListBox",0,&tolua_err) ||
11153 !tolua_isnoobj(tolua_S,3,&tolua_err)
11154 )
11155 goto tolua_lerror;
11156 else
11157 #endif
11158 {
11159 DropDown* self = (DropDown*) tolua_tousertype(tolua_S,1,0);
11160 ListBox* listBox = ((ListBox*) tolua_tousertype(tolua_S,2,0));
11161 #ifndef TOLUA_RELEASE
11162 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setListBox'", NULL);
11163 #endif
11164 {
11165 self->setListBox(listBox);
11166 }
11167 }
11168 return 0;
11169 #ifndef TOLUA_RELEASE
11170 tolua_lerror:
11171 tolua_error(tolua_S,"#ferror in function 'setListBox'.",&tolua_err);
11172 return 0;
11173 #endif
11174 }
11175 #endif //#ifndef TOLUA_DISABLE
11176
11177 /* method: getListBox of class DropDown */
11178 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDown_getListBox00
11179 static int tolua_stratagus_DropDown_getListBox00(lua_State* tolua_S)
11180 {
11181 #ifndef TOLUA_RELEASE
11182 tolua_Error tolua_err;
11183 if (
11184 !tolua_isusertype(tolua_S,1,"DropDown",0,&tolua_err) ||
11185 !tolua_isnoobj(tolua_S,2,&tolua_err)
11186 )
11187 goto tolua_lerror;
11188 else
11189 #endif
11190 {
11191 DropDown* self = (DropDown*) tolua_tousertype(tolua_S,1,0);
11192 #ifndef TOLUA_RELEASE
11193 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getListBox'", NULL);
11194 #endif
11195 {
11196 ListBox* tolua_ret = (ListBox*) self->getListBox();
11197 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ListBox");
11198 }
11199 }
11200 return 1;
11201 #ifndef TOLUA_RELEASE
11202 tolua_lerror:
11203 tolua_error(tolua_S,"#ferror in function 'getListBox'.",&tolua_err);
11204 return 0;
11205 #endif
11206 }
11207 #endif //#ifndef TOLUA_DISABLE
11208
11209 /* method: new of class DropDownWidget */
11210 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDownWidget_new00
11211 static int tolua_stratagus_DropDownWidget_new00(lua_State* tolua_S)
11212 {
11213 #ifndef TOLUA_RELEASE
11214 tolua_Error tolua_err;
11215 if (
11216 !tolua_isusertable(tolua_S,1,"DropDownWidget",0,&tolua_err) ||
11217 !tolua_isnoobj(tolua_S,2,&tolua_err)
11218 )
11219 goto tolua_lerror;
11220 else
11221 #endif
11222 {
11223 {
11224 DropDownWidget* tolua_ret = (DropDownWidget*) Mtolua_new((DropDownWidget)());
11225 tolua_pushusertype(tolua_S,(void*)tolua_ret,"DropDownWidget");
11226 }
11227 }
11228 return 1;
11229 #ifndef TOLUA_RELEASE
11230 tolua_lerror:
11231 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
11232 return 0;
11233 #endif
11234 }
11235 #endif //#ifndef TOLUA_DISABLE
11236
11237 /* method: new_local of class DropDownWidget */
11238 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDownWidget_new00_local
11239 static int tolua_stratagus_DropDownWidget_new00_local(lua_State* tolua_S)
11240 {
11241 #ifndef TOLUA_RELEASE
11242 tolua_Error tolua_err;
11243 if (
11244 !tolua_isusertable(tolua_S,1,"DropDownWidget",0,&tolua_err) ||
11245 !tolua_isnoobj(tolua_S,2,&tolua_err)
11246 )
11247 goto tolua_lerror;
11248 else
11249 #endif
11250 {
11251 {
11252 DropDownWidget* tolua_ret = (DropDownWidget*) Mtolua_new((DropDownWidget)());
11253 tolua_pushusertype(tolua_S,(void*)tolua_ret,"DropDownWidget");
11254 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
11255 }
11256 }
11257 return 1;
11258 #ifndef TOLUA_RELEASE
11259 tolua_lerror:
11260 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
11261 return 0;
11262 #endif
11263 }
11264 #endif //#ifndef TOLUA_DISABLE
11265
11266 /* method: setList of class DropDownWidget */
11267 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDownWidget_setList00
11268 static int tolua_stratagus_DropDownWidget_setList00(lua_State* tolua_S)
11269 {
11270 #ifndef TOLUA_RELEASE
11271 tolua_Error tolua_err;
11272 if (
11273 !tolua_isusertype(tolua_S,1,"DropDownWidget",0,&tolua_err) ||
11274 !tolua_isnoobj(tolua_S,3,&tolua_err)
11275 )
11276 goto tolua_lerror;
11277 else
11278 #endif
11279 {
11280 DropDownWidget* self = (DropDownWidget*) tolua_tousertype(tolua_S,1,0);
11281 lua_State* lua = tolua_S;
11282 lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
11283 #ifndef TOLUA_RELEASE
11284 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setList'", NULL);
11285 #endif
11286 {
11287 self->setList(lua,&lo);
11288 tolua_pushvalue(tolua_S,(int)lo);
11289 }
11290 }
11291 return 1;
11292 #ifndef TOLUA_RELEASE
11293 tolua_lerror:
11294 tolua_error(tolua_S,"#ferror in function 'setList'.",&tolua_err);
11295 return 0;
11296 #endif
11297 }
11298 #endif //#ifndef TOLUA_DISABLE
11299
11300 /* method: getListBox of class DropDownWidget */
11301 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDownWidget_getListBox00
11302 static int tolua_stratagus_DropDownWidget_getListBox00(lua_State* tolua_S)
11303 {
11304 #ifndef TOLUA_RELEASE
11305 tolua_Error tolua_err;
11306 if (
11307 !tolua_isusertype(tolua_S,1,"DropDownWidget",0,&tolua_err) ||
11308 !tolua_isnoobj(tolua_S,2,&tolua_err)
11309 )
11310 goto tolua_lerror;
11311 else
11312 #endif
11313 {
11314 DropDownWidget* self = (DropDownWidget*) tolua_tousertype(tolua_S,1,0);
11315 #ifndef TOLUA_RELEASE
11316 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getListBox'", NULL);
11317 #endif
11318 {
11319 ListBox* tolua_ret = (ListBox*) self->getListBox();
11320 tolua_pushusertype(tolua_S,(void*)tolua_ret,"ListBox");
11321 }
11322 }
11323 return 1;
11324 #ifndef TOLUA_RELEASE
11325 tolua_lerror:
11326 tolua_error(tolua_S,"#ferror in function 'getListBox'.",&tolua_err);
11327 return 0;
11328 #endif
11329 }
11330 #endif //#ifndef TOLUA_DISABLE
11331
11332 /* method: setSize of class DropDownWidget */
11333 #ifndef TOLUA_DISABLE_tolua_stratagus_DropDownWidget_setSize00
11334 static int tolua_stratagus_DropDownWidget_setSize00(lua_State* tolua_S)
11335 {
11336 #ifndef TOLUA_RELEASE
11337 tolua_Error tolua_err;
11338 if (
11339 !tolua_isusertype(tolua_S,1,"DropDownWidget",0,&tolua_err) ||
11340 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
11341 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
11342 !tolua_isnoobj(tolua_S,4,&tolua_err)
11343 )
11344 goto tolua_lerror;
11345 else
11346 #endif
11347 {
11348 DropDownWidget* self = (DropDownWidget*) tolua_tousertype(tolua_S,1,0);
11349 int width = ((int) tolua_tonumber(tolua_S,2,0));
11350 int height = ((int) tolua_tonumber(tolua_S,3,0));
11351 #ifndef TOLUA_RELEASE
11352 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSize'", NULL);
11353 #endif
11354 {
11355 self->setSize(width,height);
11356 }
11357 }
11358 return 0;
11359 #ifndef TOLUA_RELEASE
11360 tolua_lerror:
11361 tolua_error(tolua_S,"#ferror in function 'setSize'.",&tolua_err);
11362 return 0;
11363 #endif
11364 }
11365 #endif //#ifndef TOLUA_DISABLE
11366
11367 /* method: new of class StatBoxWidget */
11368 #ifndef TOLUA_DISABLE_tolua_stratagus_StatBoxWidget_new00
11369 static int tolua_stratagus_StatBoxWidget_new00(lua_State* tolua_S)
11370 {
11371 #ifndef TOLUA_RELEASE
11372 tolua_Error tolua_err;
11373 if (
11374 !tolua_isusertable(tolua_S,1,"StatBoxWidget",0,&tolua_err) ||
11375 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
11376 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
11377 !tolua_isnoobj(tolua_S,4,&tolua_err)
11378 )
11379 goto tolua_lerror;
11380 else
11381 #endif
11382 {
11383 int width = ((int) tolua_tonumber(tolua_S,2,0));
11384 int height = ((int) tolua_tonumber(tolua_S,3,0));
11385 {
11386 StatBoxWidget* tolua_ret = (StatBoxWidget*) Mtolua_new((StatBoxWidget)(width,height));
11387 tolua_pushusertype(tolua_S,(void*)tolua_ret,"StatBoxWidget");
11388 }
11389 }
11390 return 1;
11391 #ifndef TOLUA_RELEASE
11392 tolua_lerror:
11393 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
11394 return 0;
11395 #endif
11396 }
11397 #endif //#ifndef TOLUA_DISABLE
11398
11399 /* method: new_local of class StatBoxWidget */
11400 #ifndef TOLUA_DISABLE_tolua_stratagus_StatBoxWidget_new00_local
11401 static int tolua_stratagus_StatBoxWidget_new00_local(lua_State* tolua_S)
11402 {
11403 #ifndef TOLUA_RELEASE
11404 tolua_Error tolua_err;
11405 if (
11406 !tolua_isusertable(tolua_S,1,"StatBoxWidget",0,&tolua_err) ||
11407 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
11408 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
11409 !tolua_isnoobj(tolua_S,4,&tolua_err)
11410 )
11411 goto tolua_lerror;
11412 else
11413 #endif
11414 {
11415 int width = ((int) tolua_tonumber(tolua_S,2,0));
11416 int height = ((int) tolua_tonumber(tolua_S,3,0));
11417 {
11418 StatBoxWidget* tolua_ret = (StatBoxWidget*) Mtolua_new((StatBoxWidget)(width,height));
11419 tolua_pushusertype(tolua_S,(void*)tolua_ret,"StatBoxWidget");
11420 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
11421 }
11422 }
11423 return 1;
11424 #ifndef TOLUA_RELEASE
11425 tolua_lerror:
11426 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
11427 return 0;
11428 #endif
11429 }
11430 #endif //#ifndef TOLUA_DISABLE
11431
11432 /* method: setCaption of class StatBoxWidget */
11433 #ifndef TOLUA_DISABLE_tolua_stratagus_StatBoxWidget_setCaption00
11434 static int tolua_stratagus_StatBoxWidget_setCaption00(lua_State* tolua_S)
11435 {
11436 #ifndef TOLUA_RELEASE
11437 tolua_Error tolua_err;
11438 if (
11439 !tolua_isusertype(tolua_S,1,"StatBoxWidget",0,&tolua_err) ||
11440 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
11441 !tolua_isnoobj(tolua_S,3,&tolua_err)
11442 )
11443 goto tolua_lerror;
11444 else
11445 #endif
11446 {
11447 StatBoxWidget* self = (StatBoxWidget*) tolua_tousertype(tolua_S,1,0);
11448 const std::string s = ((const std::string) tolua_tocppstring(tolua_S,2,0));
11449 #ifndef TOLUA_RELEASE
11450 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaption'", NULL);
11451 #endif
11452 {
11453 self->setCaption(s);
11454 }
11455 }
11456 return 0;
11457 #ifndef TOLUA_RELEASE
11458 tolua_lerror:
11459 tolua_error(tolua_S,"#ferror in function 'setCaption'.",&tolua_err);
11460 return 0;
11461 #endif
11462 }
11463 #endif //#ifndef TOLUA_DISABLE
11464
11465 /* method: getCaption of class StatBoxWidget */
11466 #ifndef TOLUA_DISABLE_tolua_stratagus_StatBoxWidget_getCaption00
11467 static int tolua_stratagus_StatBoxWidget_getCaption00(lua_State* tolua_S)
11468 {
11469 #ifndef TOLUA_RELEASE
11470 tolua_Error tolua_err;
11471 if (
11472 !tolua_isusertype(tolua_S,1,"const StatBoxWidget",0,&tolua_err) ||
11473 !tolua_isnoobj(tolua_S,2,&tolua_err)
11474 )
11475 goto tolua_lerror;
11476 else
11477 #endif
11478 {
11479 const StatBoxWidget* self = (const StatBoxWidget*) tolua_tousertype(tolua_S,1,0);
11480 #ifndef TOLUA_RELEASE
11481 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaption'", NULL);
11482 #endif
11483 {
11484 const std::string tolua_ret = (const std::string) self->getCaption();
11485 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
11486 }
11487 }
11488 return 1;
11489 #ifndef TOLUA_RELEASE
11490 tolua_lerror:
11491 tolua_error(tolua_S,"#ferror in function 'getCaption'.",&tolua_err);
11492 return 0;
11493 #endif
11494 }
11495 #endif //#ifndef TOLUA_DISABLE
11496
11497 /* method: setPercent of class StatBoxWidget */
11498 #ifndef TOLUA_DISABLE_tolua_stratagus_StatBoxWidget_setPercent00
11499 static int tolua_stratagus_StatBoxWidget_setPercent00(lua_State* tolua_S)
11500 {
11501 #ifndef TOLUA_RELEASE
11502 tolua_Error tolua_err;
11503 if (
11504 !tolua_isusertype(tolua_S,1,"StatBoxWidget",0,&tolua_err) ||
11505 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
11506 !tolua_isnoobj(tolua_S,3,&tolua_err)
11507 )
11508 goto tolua_lerror;
11509 else
11510 #endif
11511 {
11512 StatBoxWidget* self = (StatBoxWidget*) tolua_tousertype(tolua_S,1,0);
11513 const int percent = ((const int) tolua_tonumber(tolua_S,2,0));
11514 #ifndef TOLUA_RELEASE
11515 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPercent'", NULL);
11516 #endif
11517 {
11518 self->setPercent(percent);
11519 }
11520 }
11521 return 0;
11522 #ifndef TOLUA_RELEASE
11523 tolua_lerror:
11524 tolua_error(tolua_S,"#ferror in function 'setPercent'.",&tolua_err);
11525 return 0;
11526 #endif
11527 }
11528 #endif //#ifndef TOLUA_DISABLE
11529
11530 /* method: getPercent of class StatBoxWidget */
11531 #ifndef TOLUA_DISABLE_tolua_stratagus_StatBoxWidget_getPercent00
11532 static int tolua_stratagus_StatBoxWidget_getPercent00(lua_State* tolua_S)
11533 {
11534 #ifndef TOLUA_RELEASE
11535 tolua_Error tolua_err;
11536 if (
11537 !tolua_isusertype(tolua_S,1,"const StatBoxWidget",0,&tolua_err) ||
11538 !tolua_isnoobj(tolua_S,2,&tolua_err)
11539 )
11540 goto tolua_lerror;
11541 else
11542 #endif
11543 {
11544 const StatBoxWidget* self = (const StatBoxWidget*) tolua_tousertype(tolua_S,1,0);
11545 #ifndef TOLUA_RELEASE
11546 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPercent'", NULL);
11547 #endif
11548 {
11549 int tolua_ret = (int) self->getPercent();
11550 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
11551 }
11552 }
11553 return 1;
11554 #ifndef TOLUA_RELEASE
11555 tolua_lerror:
11556 tolua_error(tolua_S,"#ferror in function 'getPercent'.",&tolua_err);
11557 return 0;
11558 #endif
11559 }
11560 #endif //#ifndef TOLUA_DISABLE
11561
11562 /* method: new of class Container */
11563 #ifndef TOLUA_DISABLE_tolua_stratagus_Container_new00
11564 static int tolua_stratagus_Container_new00(lua_State* tolua_S)
11565 {
11566 #ifndef TOLUA_RELEASE
11567 tolua_Error tolua_err;
11568 if (
11569 !tolua_isusertable(tolua_S,1,"Container",0,&tolua_err) ||
11570 !tolua_isnoobj(tolua_S,2,&tolua_err)
11571 )
11572 goto tolua_lerror;
11573 else
11574 #endif
11575 {
11576 {
11577 Container* tolua_ret = (Container*) Mtolua_new((Container)());
11578 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Container");
11579 }
11580 }
11581 return 1;
11582 #ifndef TOLUA_RELEASE
11583 tolua_lerror:
11584 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
11585 return 0;
11586 #endif
11587 }
11588 #endif //#ifndef TOLUA_DISABLE
11589
11590 /* method: new_local of class Container */
11591 #ifndef TOLUA_DISABLE_tolua_stratagus_Container_new00_local
11592 static int tolua_stratagus_Container_new00_local(lua_State* tolua_S)
11593 {
11594 #ifndef TOLUA_RELEASE
11595 tolua_Error tolua_err;
11596 if (
11597 !tolua_isusertable(tolua_S,1,"Container",0,&tolua_err) ||
11598 !tolua_isnoobj(tolua_S,2,&tolua_err)
11599 )
11600 goto tolua_lerror;
11601 else
11602 #endif
11603 {
11604 {
11605 Container* tolua_ret = (Container*) Mtolua_new((Container)());
11606 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Container");
11607 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
11608 }
11609 }
11610 return 1;
11611 #ifndef TOLUA_RELEASE
11612 tolua_lerror:
11613 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
11614 return 0;
11615 #endif
11616 }
11617 #endif //#ifndef TOLUA_DISABLE
11618
11619 /* method: setOpaque of class Container */
11620 #ifndef TOLUA_DISABLE_tolua_stratagus_Container_setOpaque00
11621 static int tolua_stratagus_Container_setOpaque00(lua_State* tolua_S)
11622 {
11623 #ifndef TOLUA_RELEASE
11624 tolua_Error tolua_err;
11625 if (
11626 !tolua_isusertype(tolua_S,1,"Container",0,&tolua_err) ||
11627 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
11628 !tolua_isnoobj(tolua_S,3,&tolua_err)
11629 )
11630 goto tolua_lerror;
11631 else
11632 #endif
11633 {
11634 Container* self = (Container*) tolua_tousertype(tolua_S,1,0);
11635 bool opaque = ((bool) tolua_toboolean(tolua_S,2,0));
11636 #ifndef TOLUA_RELEASE
11637 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOpaque'", NULL);
11638 #endif
11639 {
11640 self->setOpaque(opaque);
11641 }
11642 }
11643 return 0;
11644 #ifndef TOLUA_RELEASE
11645 tolua_lerror:
11646 tolua_error(tolua_S,"#ferror in function 'setOpaque'.",&tolua_err);
11647 return 0;
11648 #endif
11649 }
11650 #endif //#ifndef TOLUA_DISABLE
11651
11652 /* method: isOpaque of class Container */
11653 #ifndef TOLUA_DISABLE_tolua_stratagus_Container_isOpaque00
11654 static int tolua_stratagus_Container_isOpaque00(lua_State* tolua_S)
11655 {
11656 #ifndef TOLUA_RELEASE
11657 tolua_Error tolua_err;
11658 if (
11659 !tolua_isusertype(tolua_S,1,"const Container",0,&tolua_err) ||
11660 !tolua_isnoobj(tolua_S,2,&tolua_err)
11661 )
11662 goto tolua_lerror;
11663 else
11664 #endif
11665 {
11666 const Container* self = (const Container*) tolua_tousertype(tolua_S,1,0);
11667 #ifndef TOLUA_RELEASE
11668 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isOpaque'", NULL);
11669 #endif
11670 {
11671 bool tolua_ret = (bool) self->isOpaque();
11672 tolua_pushboolean(tolua_S,(bool)tolua_ret);
11673 }
11674 }
11675 return 1;
11676 #ifndef TOLUA_RELEASE
11677 tolua_lerror:
11678 tolua_error(tolua_S,"#ferror in function 'isOpaque'.",&tolua_err);
11679 return 0;
11680 #endif
11681 }
11682 #endif //#ifndef TOLUA_DISABLE
11683
11684 /* method: add of class Container */
11685 #ifndef TOLUA_DISABLE_tolua_stratagus_Container_add00
11686 static int tolua_stratagus_Container_add00(lua_State* tolua_S)
11687 {
11688 #ifndef TOLUA_RELEASE
11689 tolua_Error tolua_err;
11690 if (
11691 !tolua_isusertype(tolua_S,1,"Container",0,&tolua_err) ||
11692 !tolua_isusertype(tolua_S,2,"Widget",0,&tolua_err) ||
11693 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
11694 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
11695 !tolua_isnoobj(tolua_S,5,&tolua_err)
11696 )
11697 goto tolua_lerror;
11698 else
11699 #endif
11700 {
11701 Container* self = (Container*) tolua_tousertype(tolua_S,1,0);
11702 Widget* widget = ((Widget*) tolua_tousertype(tolua_S,2,0));
11703 int x = ((int) tolua_tonumber(tolua_S,3,0));
11704 int y = ((int) tolua_tonumber(tolua_S,4,0));
11705 #ifndef TOLUA_RELEASE
11706 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'", NULL);
11707 #endif
11708 {
11709 self->add(widget,x,y);
11710 }
11711 }
11712 return 0;
11713 #ifndef TOLUA_RELEASE
11714 tolua_lerror:
11715 tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
11716 return 0;
11717 #endif
11718 }
11719 #endif //#ifndef TOLUA_DISABLE
11720
11721 /* method: remove of class Container */
11722 #ifndef TOLUA_DISABLE_tolua_stratagus_Container_remove00
11723 static int tolua_stratagus_Container_remove00(lua_State* tolua_S)
11724 {
11725 #ifndef TOLUA_RELEASE
11726 tolua_Error tolua_err;
11727 if (
11728 !tolua_isusertype(tolua_S,1,"Container",0,&tolua_err) ||
11729 !tolua_isusertype(tolua_S,2,"Widget",0,&tolua_err) ||
11730 !tolua_isnoobj(tolua_S,3,&tolua_err)
11731 )
11732 goto tolua_lerror;
11733 else
11734 #endif
11735 {
11736 Container* self = (Container*) tolua_tousertype(tolua_S,1,0);
11737 Widget* widget = ((Widget*) tolua_tousertype(tolua_S,2,0));
11738 #ifndef TOLUA_RELEASE
11739 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
11740 #endif
11741 {
11742 self->remove(widget);
11743 }
11744 }
11745 return 0;
11746 #ifndef TOLUA_RELEASE
11747 tolua_lerror:
11748 tolua_error(tolua_S,"#ferror in function 'remove'.",&tolua_err);
11749 return 0;
11750 #endif
11751 }
11752 #endif //#ifndef TOLUA_DISABLE
11753
11754 /* method: clear of class Container */
11755 #ifndef TOLUA_DISABLE_tolua_stratagus_Container_clear00
11756 static int tolua_stratagus_Container_clear00(lua_State* tolua_S)
11757 {
11758 #ifndef TOLUA_RELEASE
11759 tolua_Error tolua_err;
11760 if (
11761 !tolua_isusertype(tolua_S,1,"Container",0,&tolua_err) ||
11762 !tolua_isnoobj(tolua_S,2,&tolua_err)
11763 )
11764 goto tolua_lerror;
11765 else
11766 #endif
11767 {
11768 Container* self = (Container*) tolua_tousertype(tolua_S,1,0);
11769 #ifndef TOLUA_RELEASE
11770 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
11771 #endif
11772 {
11773 self->clear();
11774 }
11775 }
11776 return 0;
11777 #ifndef TOLUA_RELEASE
11778 tolua_lerror:
11779 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
11780 return 0;
11781 #endif
11782 }
11783 #endif //#ifndef TOLUA_DISABLE
11784
11785 /* method: new of class MenuScreen */
11786 #ifndef TOLUA_DISABLE_tolua_stratagus_CMenuScreen_new00
11787 static int tolua_stratagus_CMenuScreen_new00(lua_State* tolua_S)
11788 {
11789 #ifndef TOLUA_RELEASE
11790 tolua_Error tolua_err;
11791 if (
11792 !tolua_isusertable(tolua_S,1,"MenuScreen",0,&tolua_err) ||
11793 !tolua_isnoobj(tolua_S,2,&tolua_err)
11794 )
11795 goto tolua_lerror;
11796 else
11797 #endif
11798 {
11799 {
11800 MenuScreen* tolua_ret = (MenuScreen*) Mtolua_new((MenuScreen)());
11801 tolua_pushusertype(tolua_S,(void*)tolua_ret,"MenuScreen");
11802 }
11803 }
11804 return 1;
11805 #ifndef TOLUA_RELEASE
11806 tolua_lerror:
11807 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
11808 return 0;
11809 #endif
11810 }
11811 #endif //#ifndef TOLUA_DISABLE
11812
11813 /* method: new_local of class MenuScreen */
11814 #ifndef TOLUA_DISABLE_tolua_stratagus_CMenuScreen_new00_local
11815 static int tolua_stratagus_CMenuScreen_new00_local(lua_State* tolua_S)
11816 {
11817 #ifndef TOLUA_RELEASE
11818 tolua_Error tolua_err;
11819 if (
11820 !tolua_isusertable(tolua_S,1,"MenuScreen",0,&tolua_err) ||
11821 !tolua_isnoobj(tolua_S,2,&tolua_err)
11822 )
11823 goto tolua_lerror;
11824 else
11825 #endif
11826 {
11827 {
11828 MenuScreen* tolua_ret = (MenuScreen*) Mtolua_new((MenuScreen)());
11829 tolua_pushusertype(tolua_S,(void*)tolua_ret,"MenuScreen");
11830 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
11831 }
11832 }
11833 return 1;
11834 #ifndef TOLUA_RELEASE
11835 tolua_lerror:
11836 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
11837 return 0;
11838 #endif
11839 }
11840 #endif //#ifndef TOLUA_DISABLE
11841
11842 /* method: run of class MenuScreen */
11843 #ifndef TOLUA_DISABLE_tolua_stratagus_CMenuScreen_run00
11844 static int tolua_stratagus_CMenuScreen_run00(lua_State* tolua_S)
11845 {
11846 #ifndef TOLUA_RELEASE
11847 tolua_Error tolua_err;
11848 if (
11849 !tolua_isusertype(tolua_S,1,"MenuScreen",0,&tolua_err) ||
11850 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
11851 !tolua_isnoobj(tolua_S,3,&tolua_err)
11852 )
11853 goto tolua_lerror;
11854 else
11855 #endif
11856 {
11857 MenuScreen* self = (MenuScreen*) tolua_tousertype(tolua_S,1,0);
11858 bool loop = ((bool) tolua_toboolean(tolua_S,2,true));
11859 #ifndef TOLUA_RELEASE
11860 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'run'", NULL);
11861 #endif
11862 {
11863 int tolua_ret = (int) self->run(loop);
11864 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
11865 }
11866 }
11867 return 1;
11868 #ifndef TOLUA_RELEASE
11869 tolua_lerror:
11870 tolua_error(tolua_S,"#ferror in function 'run'.",&tolua_err);
11871 return 0;
11872 #endif
11873 }
11874 #endif //#ifndef TOLUA_DISABLE
11875
11876 /* method: stop of class MenuScreen */
11877 #ifndef TOLUA_DISABLE_tolua_stratagus_CMenuScreen_stop00
11878 static int tolua_stratagus_CMenuScreen_stop00(lua_State* tolua_S)
11879 {
11880 #ifndef TOLUA_RELEASE
11881 tolua_Error tolua_err;
11882 if (
11883 !tolua_isusertype(tolua_S,1,"MenuScreen",0,&tolua_err) ||
11884 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
11885 !tolua_isnoobj(tolua_S,3,&tolua_err)
11886 )
11887 goto tolua_lerror;
11888 else
11889 #endif
11890 {
11891 MenuScreen* self = (MenuScreen*) tolua_tousertype(tolua_S,1,0);
11892 int result = ((int) tolua_tonumber(tolua_S,2,0));
11893 #ifndef TOLUA_RELEASE
11894 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stop'", NULL);
11895 #endif
11896 {
11897 self->stop(result);
11898 }
11899 }
11900 return 0;
11901 #ifndef TOLUA_RELEASE
11902 tolua_lerror:
11903 tolua_error(tolua_S,"#ferror in function 'stop'.",&tolua_err);
11904 return 0;
11905 #endif
11906 }
11907 #endif //#ifndef TOLUA_DISABLE
11908
11909 /* method: stopAll of class MenuScreen */
11910 #ifndef TOLUA_DISABLE_tolua_stratagus_CMenuScreen_stopAll00
11911 static int tolua_stratagus_CMenuScreen_stopAll00(lua_State* tolua_S)
11912 {
11913 #ifndef TOLUA_RELEASE
11914 tolua_Error tolua_err;
11915 if (
11916 !tolua_isusertype(tolua_S,1,"MenuScreen",0,&tolua_err) ||
11917 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
11918 !tolua_isnoobj(tolua_S,3,&tolua_err)
11919 )
11920 goto tolua_lerror;
11921 else
11922 #endif
11923 {
11924 MenuScreen* self = (MenuScreen*) tolua_tousertype(tolua_S,1,0);
11925 int result = ((int) tolua_tonumber(tolua_S,2,0));
11926 #ifndef TOLUA_RELEASE
11927 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stopAll'", NULL);
11928 #endif
11929 {
11930 self->stopAll(result);
11931 }
11932 }
11933 return 0;
11934 #ifndef TOLUA_RELEASE
11935 tolua_lerror:
11936 tolua_error(tolua_S,"#ferror in function 'stopAll'.",&tolua_err);
11937 return 0;
11938 #endif
11939 }
11940 #endif //#ifndef TOLUA_DISABLE
11941
11942 /* method: addLogicCallback of class MenuScreen */
11943 #ifndef TOLUA_DISABLE_tolua_stratagus_CMenuScreen_addLogicCallback00
11944 static int tolua_stratagus_CMenuScreen_addLogicCallback00(lua_State* tolua_S)
11945 {
11946 #ifndef TOLUA_RELEASE
11947 tolua_Error tolua_err;
11948 if (
11949 !tolua_isusertype(tolua_S,1,"MenuScreen",0,&tolua_err) ||
11950 !tolua_isusertype(tolua_S,2,"LuaActionListener",0,&tolua_err) ||
11951 !tolua_isnoobj(tolua_S,3,&tolua_err)
11952 )
11953 goto tolua_lerror;
11954 else
11955 #endif
11956 {
11957 MenuScreen* self = (MenuScreen*) tolua_tousertype(tolua_S,1,0);
11958 LuaActionListener* actionListener = ((LuaActionListener*) tolua_tousertype(tolua_S,2,0));
11959 #ifndef TOLUA_RELEASE
11960 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addLogicCallback'", NULL);
11961 #endif
11962 {
11963 self->addLogicCallback(actionListener);
11964 }
11965 }
11966 return 0;
11967 #ifndef TOLUA_RELEASE
11968 tolua_lerror:
11969 tolua_error(tolua_S,"#ferror in function 'addLogicCallback'.",&tolua_err);
11970 return 0;
11971 #endif
11972 }
11973 #endif //#ifndef TOLUA_DISABLE
11974
11975 /* method: setDrawMenusUnder of class MenuScreen */
11976 #ifndef TOLUA_DISABLE_tolua_stratagus_CMenuScreen_setDrawMenusUnder00
11977 static int tolua_stratagus_CMenuScreen_setDrawMenusUnder00(lua_State* tolua_S)
11978 {
11979 #ifndef TOLUA_RELEASE
11980 tolua_Error tolua_err;
11981 if (
11982 !tolua_isusertype(tolua_S,1,"MenuScreen",0,&tolua_err) ||
11983 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
11984 !tolua_isnoobj(tolua_S,3,&tolua_err)
11985 )
11986 goto tolua_lerror;
11987 else
11988 #endif
11989 {
11990 MenuScreen* self = (MenuScreen*) tolua_tousertype(tolua_S,1,0);
11991 bool drawunder = ((bool) tolua_toboolean(tolua_S,2,0));
11992 #ifndef TOLUA_RELEASE
11993 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDrawMenusUnder'", NULL);
11994 #endif
11995 {
11996 self->setDrawMenusUnder(drawunder);
11997 }
11998 }
11999 return 0;
12000 #ifndef TOLUA_RELEASE
12001 tolua_lerror:
12002 tolua_error(tolua_S,"#ferror in function 'setDrawMenusUnder'.",&tolua_err);
12003 return 0;
12004 #endif
12005 }
12006 #endif //#ifndef TOLUA_DISABLE
12007
12008 /* method: getDrawMenusUnder of class MenuScreen */
12009 #ifndef TOLUA_DISABLE_tolua_stratagus_CMenuScreen_getDrawMenusUnder00
12010 static int tolua_stratagus_CMenuScreen_getDrawMenusUnder00(lua_State* tolua_S)
12011 {
12012 #ifndef TOLUA_RELEASE
12013 tolua_Error tolua_err;
12014 if (
12015 !tolua_isusertype(tolua_S,1,"MenuScreen",0,&tolua_err) ||
12016 !tolua_isnoobj(tolua_S,2,&tolua_err)
12017 )
12018 goto tolua_lerror;
12019 else
12020 #endif
12021 {
12022 MenuScreen* self = (MenuScreen*) tolua_tousertype(tolua_S,1,0);
12023 #ifndef TOLUA_RELEASE
12024 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDrawMenusUnder'", NULL);
12025 #endif
12026 {
12027 bool tolua_ret = (bool) self->getDrawMenusUnder();
12028 tolua_pushboolean(tolua_S,(bool)tolua_ret);
12029 }
12030 }
12031 return 1;
12032 #ifndef TOLUA_RELEASE
12033 tolua_lerror:
12034 tolua_error(tolua_S,"#ferror in function 'getDrawMenusUnder'.",&tolua_err);
12035 return 0;
12036 #endif
12037 }
12038 #endif //#ifndef TOLUA_DISABLE
12039
12040 /* function: InitNetwork1 */
12041 #ifndef TOLUA_DISABLE_tolua_stratagus_InitNetwork100
12042 static int tolua_stratagus_InitNetwork100(lua_State* tolua_S)
12043 {
12044 #ifndef TOLUA_RELEASE
12045 tolua_Error tolua_err;
12046 if (
12047 !tolua_isnoobj(tolua_S,1,&tolua_err)
12048 )
12049 goto tolua_lerror;
12050 else
12051 #endif
12052 {
12053 {
12054 InitNetwork1();
12055 }
12056 }
12057 return 0;
12058 #ifndef TOLUA_RELEASE
12059 tolua_lerror:
12060 tolua_error(tolua_S,"#ferror in function 'InitNetwork1'.",&tolua_err);
12061 return 0;
12062 #endif
12063 }
12064 #endif //#ifndef TOLUA_DISABLE
12065
12066 /* function: ExitNetwork1 */
12067 #ifndef TOLUA_DISABLE_tolua_stratagus_ExitNetwork100
12068 static int tolua_stratagus_ExitNetwork100(lua_State* tolua_S)
12069 {
12070 #ifndef TOLUA_RELEASE
12071 tolua_Error tolua_err;
12072 if (
12073 !tolua_isnoobj(tolua_S,1,&tolua_err)
12074 )
12075 goto tolua_lerror;
12076 else
12077 #endif
12078 {
12079 {
12080 ExitNetwork1();
12081 }
12082 }
12083 return 0;
12084 #ifndef TOLUA_RELEASE
12085 tolua_lerror:
12086 tolua_error(tolua_S,"#ferror in function 'ExitNetwork1'.",&tolua_err);
12087 return 0;
12088 #endif
12089 }
12090 #endif //#ifndef TOLUA_DISABLE
12091
12092 /* function: IsNetworkGame */
12093 #ifndef TOLUA_DISABLE_tolua_stratagus_IsNetworkGame00
12094 static int tolua_stratagus_IsNetworkGame00(lua_State* tolua_S)
12095 {
12096 #ifndef TOLUA_RELEASE
12097 tolua_Error tolua_err;
12098 if (
12099 !tolua_isnoobj(tolua_S,1,&tolua_err)
12100 )
12101 goto tolua_lerror;
12102 else
12103 #endif
12104 {
12105 {
12106 bool tolua_ret = (bool) IsNetworkGame();
12107 tolua_pushboolean(tolua_S,(bool)tolua_ret);
12108 }
12109 }
12110 return 1;
12111 #ifndef TOLUA_RELEASE
12112 tolua_lerror:
12113 tolua_error(tolua_S,"#ferror in function 'IsNetworkGame'.",&tolua_err);
12114 return 0;
12115 #endif
12116 }
12117 #endif //#ifndef TOLUA_DISABLE
12118
12119 /* function: NetworkSetupServerAddress */
12120 #ifndef TOLUA_DISABLE_tolua_stratagus_NetworkSetupServerAddress00
12121 static int tolua_stratagus_NetworkSetupServerAddress00(lua_State* tolua_S)
12122 {
12123 #ifndef TOLUA_RELEASE
12124 tolua_Error tolua_err;
12125 if (
12126 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
12127 !tolua_isnoobj(tolua_S,2,&tolua_err)
12128 )
12129 goto tolua_lerror;
12130 else
12131 #endif
12132 {
12133 const std::string serveraddr = ((const std::string) tolua_tocppstring(tolua_S,1,0));
12134 {
12135 int tolua_ret = (int) NetworkSetupServerAddress(serveraddr);
12136 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
12137 }
12138 }
12139 return 1;
12140 #ifndef TOLUA_RELEASE
12141 tolua_lerror:
12142 tolua_error(tolua_S,"#ferror in function 'NetworkSetupServerAddress'.",&tolua_err);
12143 return 0;
12144 #endif
12145 }
12146 #endif //#ifndef TOLUA_DISABLE
12147
12148 /* function: NetworkInitClientConnect */
12149 #ifndef TOLUA_DISABLE_tolua_stratagus_NetworkInitClientConnect00
12150 static int tolua_stratagus_NetworkInitClientConnect00(lua_State* tolua_S)
12151 {
12152 #ifndef TOLUA_RELEASE
12153 tolua_Error tolua_err;
12154 if (
12155 !tolua_isnoobj(tolua_S,1,&tolua_err)
12156 )
12157 goto tolua_lerror;
12158 else
12159 #endif
12160 {
12161 {
12162 NetworkInitClientConnect();
12163 }
12164 }
12165 return 0;
12166 #ifndef TOLUA_RELEASE
12167 tolua_lerror:
12168 tolua_error(tolua_S,"#ferror in function 'NetworkInitClientConnect'.",&tolua_err);
12169 return 0;
12170 #endif
12171 }
12172 #endif //#ifndef TOLUA_DISABLE
12173
12174 /* function: NetworkInitServerConnect */
12175 #ifndef TOLUA_DISABLE_tolua_stratagus_NetworkInitServerConnect00
12176 static int tolua_stratagus_NetworkInitServerConnect00(lua_State* tolua_S)
12177 {
12178 #ifndef TOLUA_RELEASE
12179 tolua_Error tolua_err;
12180 if (
12181 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
12182 !tolua_isnoobj(tolua_S,2,&tolua_err)
12183 )
12184 goto tolua_lerror;
12185 else
12186 #endif
12187 {
12188 int openslots = ((int) tolua_tonumber(tolua_S,1,0));
12189 {
12190 NetworkInitServerConnect(openslots);
12191 }
12192 }
12193 return 0;
12194 #ifndef TOLUA_RELEASE
12195 tolua_lerror:
12196 tolua_error(tolua_S,"#ferror in function 'NetworkInitServerConnect'.",&tolua_err);
12197 return 0;
12198 #endif
12199 }
12200 #endif //#ifndef TOLUA_DISABLE
12201
12202 /* function: NetworkServerStartGame */
12203 #ifndef TOLUA_DISABLE_tolua_stratagus_NetworkServerStartGame00
12204 static int tolua_stratagus_NetworkServerStartGame00(lua_State* tolua_S)
12205 {
12206 #ifndef TOLUA_RELEASE
12207 tolua_Error tolua_err;
12208 if (
12209 !tolua_isnoobj(tolua_S,1,&tolua_err)
12210 )
12211 goto tolua_lerror;
12212 else
12213 #endif
12214 {
12215 {
12216 NetworkServerStartGame();
12217 }
12218 }
12219 return 0;
12220 #ifndef TOLUA_RELEASE
12221 tolua_lerror:
12222 tolua_error(tolua_S,"#ferror in function 'NetworkServerStartGame'.",&tolua_err);
12223 return 0;
12224 #endif
12225 }
12226 #endif //#ifndef TOLUA_DISABLE
12227
12228 /* function: NetworkProcessClientRequest */
12229 #ifndef TOLUA_DISABLE_tolua_stratagus_NetworkProcessClientRequest00
12230 static int tolua_stratagus_NetworkProcessClientRequest00(lua_State* tolua_S)
12231 {
12232 #ifndef TOLUA_RELEASE
12233 tolua_Error tolua_err;
12234 if (
12235 !tolua_isnoobj(tolua_S,1,&tolua_err)
12236 )
12237 goto tolua_lerror;
12238 else
12239 #endif
12240 {
12241 {
12242 NetworkProcessClientRequest();
12243 }
12244 }
12245 return 0;
12246 #ifndef TOLUA_RELEASE
12247 tolua_lerror:
12248 tolua_error(tolua_S,"#ferror in function 'NetworkProcessClientRequest'.",&tolua_err);
12249 return 0;
12250 #endif
12251 }
12252 #endif //#ifndef TOLUA_DISABLE
12253
12254 /* function: GetNetworkState */
12255 #ifndef TOLUA_DISABLE_tolua_stratagus_GetNetworkState00
12256 static int tolua_stratagus_GetNetworkState00(lua_State* tolua_S)
12257 {
12258 #ifndef TOLUA_RELEASE
12259 tolua_Error tolua_err;
12260 if (
12261 !tolua_isnoobj(tolua_S,1,&tolua_err)
12262 )
12263 goto tolua_lerror;
12264 else
12265 #endif
12266 {
12267 {
12268 int tolua_ret = (int) GetNetworkState();
12269 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
12270 }
12271 }
12272 return 1;
12273 #ifndef TOLUA_RELEASE
12274 tolua_lerror:
12275 tolua_error(tolua_S,"#ferror in function 'GetNetworkState'.",&tolua_err);
12276 return 0;
12277 #endif
12278 }
12279 #endif //#ifndef TOLUA_DISABLE
12280
12281 /* function: NetworkServerResyncClients */
12282 #ifndef TOLUA_DISABLE_tolua_stratagus_NetworkServerResyncClients00
12283 static int tolua_stratagus_NetworkServerResyncClients00(lua_State* tolua_S)
12284 {
12285 #ifndef TOLUA_RELEASE
12286 tolua_Error tolua_err;
12287 if (
12288 !tolua_isnoobj(tolua_S,1,&tolua_err)
12289 )
12290 goto tolua_lerror;
12291 else
12292 #endif
12293 {
12294 {
12295 NetworkServerResyncClients();
12296 }
12297 }
12298 return 0;
12299 #ifndef TOLUA_RELEASE
12300 tolua_lerror:
12301 tolua_error(tolua_S,"#ferror in function 'NetworkServerResyncClients'.",&tolua_err);
12302 return 0;
12303 #endif
12304 }
12305 #endif //#ifndef TOLUA_DISABLE
12306
12307 /* function: NetworkDetachFromServer */
12308 #ifndef TOLUA_DISABLE_tolua_stratagus_NetworkDetachFromServer00
12309 static int tolua_stratagus_NetworkDetachFromServer00(lua_State* tolua_S)
12310 {
12311 #ifndef TOLUA_RELEASE
12312 tolua_Error tolua_err;
12313 if (
12314 !tolua_isnoobj(tolua_S,1,&tolua_err)
12315 )
12316 goto tolua_lerror;
12317 else
12318 #endif
12319 {
12320 {
12321 NetworkDetachFromServer();
12322 }
12323 }
12324 return 0;
12325 #ifndef TOLUA_RELEASE
12326 tolua_lerror:
12327 tolua_error(tolua_S,"#ferror in function 'NetworkDetachFromServer'.",&tolua_err);
12328 return 0;
12329 #endif
12330 }
12331 #endif //#ifndef TOLUA_DISABLE
12332
12333 /* get function: ResourcesOption of class CServerSetup */
12334 #ifndef TOLUA_DISABLE_tolua_get_CServerSetup_unsigned_ResourcesOption
12335 static int tolua_get_CServerSetup_unsigned_ResourcesOption(lua_State* tolua_S)
12336 {
12337 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12338 #ifndef TOLUA_RELEASE
12339 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ResourcesOption'",NULL);
12340 #endif
12341 tolua_pushnumber(tolua_S,(lua_Number)self->ResourcesOption);
12342 return 1;
12343 }
12344 #endif //#ifndef TOLUA_DISABLE
12345
12346 /* set function: ResourcesOption of class CServerSetup */
12347 #ifndef TOLUA_DISABLE_tolua_set_CServerSetup_unsigned_ResourcesOption
12348 static int tolua_set_CServerSetup_unsigned_ResourcesOption(lua_State* tolua_S)
12349 {
12350 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12351 #ifndef TOLUA_RELEASE
12352 tolua_Error tolua_err;
12353 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ResourcesOption'",NULL);
12354 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12355 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12356 #endif
12357 self->ResourcesOption = ((unsigned char) tolua_tonumber(tolua_S,2,0))
12358 ;
12359 return 0;
12360 }
12361 #endif //#ifndef TOLUA_DISABLE
12362
12363 /* get function: UnitsOption of class CServerSetup */
12364 #ifndef TOLUA_DISABLE_tolua_get_CServerSetup_unsigned_UnitsOption
12365 static int tolua_get_CServerSetup_unsigned_UnitsOption(lua_State* tolua_S)
12366 {
12367 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12368 #ifndef TOLUA_RELEASE
12369 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UnitsOption'",NULL);
12370 #endif
12371 tolua_pushnumber(tolua_S,(lua_Number)self->UnitsOption);
12372 return 1;
12373 }
12374 #endif //#ifndef TOLUA_DISABLE
12375
12376 /* set function: UnitsOption of class CServerSetup */
12377 #ifndef TOLUA_DISABLE_tolua_set_CServerSetup_unsigned_UnitsOption
12378 static int tolua_set_CServerSetup_unsigned_UnitsOption(lua_State* tolua_S)
12379 {
12380 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12381 #ifndef TOLUA_RELEASE
12382 tolua_Error tolua_err;
12383 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UnitsOption'",NULL);
12384 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12385 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12386 #endif
12387 self->UnitsOption = ((unsigned char) tolua_tonumber(tolua_S,2,0))
12388 ;
12389 return 0;
12390 }
12391 #endif //#ifndef TOLUA_DISABLE
12392
12393 /* get function: FogOfWar of class CServerSetup */
12394 #ifndef TOLUA_DISABLE_tolua_get_CServerSetup_unsigned_FogOfWar
12395 static int tolua_get_CServerSetup_unsigned_FogOfWar(lua_State* tolua_S)
12396 {
12397 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12398 #ifndef TOLUA_RELEASE
12399 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FogOfWar'",NULL);
12400 #endif
12401 tolua_pushnumber(tolua_S,(lua_Number)self->FogOfWar);
12402 return 1;
12403 }
12404 #endif //#ifndef TOLUA_DISABLE
12405
12406 /* set function: FogOfWar of class CServerSetup */
12407 #ifndef TOLUA_DISABLE_tolua_set_CServerSetup_unsigned_FogOfWar
12408 static int tolua_set_CServerSetup_unsigned_FogOfWar(lua_State* tolua_S)
12409 {
12410 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12411 #ifndef TOLUA_RELEASE
12412 tolua_Error tolua_err;
12413 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FogOfWar'",NULL);
12414 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12415 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12416 #endif
12417 self->FogOfWar = ((unsigned char) tolua_tonumber(tolua_S,2,0))
12418 ;
12419 return 0;
12420 }
12421 #endif //#ifndef TOLUA_DISABLE
12422
12423 /* get function: RevealMap of class CServerSetup */
12424 #ifndef TOLUA_DISABLE_tolua_get_CServerSetup_unsigned_RevealMap
12425 static int tolua_get_CServerSetup_unsigned_RevealMap(lua_State* tolua_S)
12426 {
12427 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12428 #ifndef TOLUA_RELEASE
12429 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RevealMap'",NULL);
12430 #endif
12431 tolua_pushnumber(tolua_S,(lua_Number)self->RevealMap);
12432 return 1;
12433 }
12434 #endif //#ifndef TOLUA_DISABLE
12435
12436 /* set function: RevealMap of class CServerSetup */
12437 #ifndef TOLUA_DISABLE_tolua_set_CServerSetup_unsigned_RevealMap
12438 static int tolua_set_CServerSetup_unsigned_RevealMap(lua_State* tolua_S)
12439 {
12440 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12441 #ifndef TOLUA_RELEASE
12442 tolua_Error tolua_err;
12443 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RevealMap'",NULL);
12444 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12445 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12446 #endif
12447 self->RevealMap = ((unsigned char) tolua_tonumber(tolua_S,2,0))
12448 ;
12449 return 0;
12450 }
12451 #endif //#ifndef TOLUA_DISABLE
12452
12453 /* get function: GameTypeOption of class CServerSetup */
12454 #ifndef TOLUA_DISABLE_tolua_get_CServerSetup_unsigned_GameTypeOption
12455 static int tolua_get_CServerSetup_unsigned_GameTypeOption(lua_State* tolua_S)
12456 {
12457 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12458 #ifndef TOLUA_RELEASE
12459 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GameTypeOption'",NULL);
12460 #endif
12461 tolua_pushnumber(tolua_S,(lua_Number)self->GameTypeOption);
12462 return 1;
12463 }
12464 #endif //#ifndef TOLUA_DISABLE
12465
12466 /* set function: GameTypeOption of class CServerSetup */
12467 #ifndef TOLUA_DISABLE_tolua_set_CServerSetup_unsigned_GameTypeOption
12468 static int tolua_set_CServerSetup_unsigned_GameTypeOption(lua_State* tolua_S)
12469 {
12470 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12471 #ifndef TOLUA_RELEASE
12472 tolua_Error tolua_err;
12473 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GameTypeOption'",NULL);
12474 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12475 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12476 #endif
12477 self->GameTypeOption = ((unsigned char) tolua_tonumber(tolua_S,2,0))
12478 ;
12479 return 0;
12480 }
12481 #endif //#ifndef TOLUA_DISABLE
12482
12483 /* get function: Difficulty of class CServerSetup */
12484 #ifndef TOLUA_DISABLE_tolua_get_CServerSetup_unsigned_Difficulty
12485 static int tolua_get_CServerSetup_unsigned_Difficulty(lua_State* tolua_S)
12486 {
12487 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12488 #ifndef TOLUA_RELEASE
12489 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Difficulty'",NULL);
12490 #endif
12491 tolua_pushnumber(tolua_S,(lua_Number)self->Difficulty);
12492 return 1;
12493 }
12494 #endif //#ifndef TOLUA_DISABLE
12495
12496 /* set function: Difficulty of class CServerSetup */
12497 #ifndef TOLUA_DISABLE_tolua_set_CServerSetup_unsigned_Difficulty
12498 static int tolua_set_CServerSetup_unsigned_Difficulty(lua_State* tolua_S)
12499 {
12500 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12501 #ifndef TOLUA_RELEASE
12502 tolua_Error tolua_err;
12503 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Difficulty'",NULL);
12504 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12505 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12506 #endif
12507 self->Difficulty = ((unsigned char) tolua_tonumber(tolua_S,2,0))
12508 ;
12509 return 0;
12510 }
12511 #endif //#ifndef TOLUA_DISABLE
12512
12513 /* get function: MapRichness of class CServerSetup */
12514 #ifndef TOLUA_DISABLE_tolua_get_CServerSetup_unsigned_MapRichness
12515 static int tolua_get_CServerSetup_unsigned_MapRichness(lua_State* tolua_S)
12516 {
12517 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12518 #ifndef TOLUA_RELEASE
12519 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapRichness'",NULL);
12520 #endif
12521 tolua_pushnumber(tolua_S,(lua_Number)self->MapRichness);
12522 return 1;
12523 }
12524 #endif //#ifndef TOLUA_DISABLE
12525
12526 /* set function: MapRichness of class CServerSetup */
12527 #ifndef TOLUA_DISABLE_tolua_set_CServerSetup_unsigned_MapRichness
12528 static int tolua_set_CServerSetup_unsigned_MapRichness(lua_State* tolua_S)
12529 {
12530 CServerSetup* self = (CServerSetup*) tolua_tousertype(tolua_S,1,0);
12531 #ifndef TOLUA_RELEASE
12532 tolua_Error tolua_err;
12533 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapRichness'",NULL);
12534 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12535 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12536 #endif
12537 self->MapRichness = ((unsigned char) tolua_tonumber(tolua_S,2,0))
12538 ;
12539 return 0;
12540 }
12541 #endif //#ifndef TOLUA_DISABLE
12542
12543 /* get function: CompOpt of class CServerSetup */
12544 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CServerSetup_CompOpt
12545 static int tolua_get_stratagus_CServerSetup_CompOpt(lua_State* tolua_S)
12546 {
12547 int tolua_index;
12548 CServerSetup* self;
12549 lua_pushstring(tolua_S,".self");
12550 lua_rawget(tolua_S,1);
12551 self = (CServerSetup*) lua_touserdata(tolua_S,-1);
12552 #ifndef TOLUA_RELEASE
12553 {
12554 tolua_Error tolua_err;
12555 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12556 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
12557 }
12558 #endif
12559 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
12560 #ifndef TOLUA_RELEASE
12561 if (tolua_index<0 || tolua_index>=PlayerMax)
12562 tolua_error(tolua_S,"array indexing out of range.",NULL);
12563 #endif
12564 tolua_pushnumber(tolua_S,(lua_Number)self->CompOpt[tolua_index]);
12565 return 1;
12566 }
12567 #endif //#ifndef TOLUA_DISABLE
12568
12569 /* set function: CompOpt of class CServerSetup */
12570 #ifndef TOLUA_DISABLE_tolua_set_stratagus_CServerSetup_CompOpt
12571 static int tolua_set_stratagus_CServerSetup_CompOpt(lua_State* tolua_S)
12572 {
12573 int tolua_index;
12574 CServerSetup* self;
12575 lua_pushstring(tolua_S,".self");
12576 lua_rawget(tolua_S,1);
12577 self = (CServerSetup*) lua_touserdata(tolua_S,-1);
12578 #ifndef TOLUA_RELEASE
12579 {
12580 tolua_Error tolua_err;
12581 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12582 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
12583 }
12584 #endif
12585 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
12586 #ifndef TOLUA_RELEASE
12587 if (tolua_index<0 || tolua_index>=PlayerMax)
12588 tolua_error(tolua_S,"array indexing out of range.",NULL);
12589 #endif
12590 self->CompOpt[tolua_index] = ((unsigned) tolua_tonumber(tolua_S,3,0));
12591 return 0;
12592 }
12593 #endif //#ifndef TOLUA_DISABLE
12594
12595 /* get function: Ready of class CServerSetup */
12596 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CServerSetup_Ready
12597 static int tolua_get_stratagus_CServerSetup_Ready(lua_State* tolua_S)
12598 {
12599 int tolua_index;
12600 CServerSetup* self;
12601 lua_pushstring(tolua_S,".self");
12602 lua_rawget(tolua_S,1);
12603 self = (CServerSetup*) lua_touserdata(tolua_S,-1);
12604 #ifndef TOLUA_RELEASE
12605 {
12606 tolua_Error tolua_err;
12607 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12608 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
12609 }
12610 #endif
12611 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
12612 #ifndef TOLUA_RELEASE
12613 if (tolua_index<0 || tolua_index>=PlayerMax)
12614 tolua_error(tolua_S,"array indexing out of range.",NULL);
12615 #endif
12616 tolua_pushnumber(tolua_S,(lua_Number)self->Ready[tolua_index]);
12617 return 1;
12618 }
12619 #endif //#ifndef TOLUA_DISABLE
12620
12621 /* set function: Ready of class CServerSetup */
12622 #ifndef TOLUA_DISABLE_tolua_set_stratagus_CServerSetup_Ready
12623 static int tolua_set_stratagus_CServerSetup_Ready(lua_State* tolua_S)
12624 {
12625 int tolua_index;
12626 CServerSetup* self;
12627 lua_pushstring(tolua_S,".self");
12628 lua_rawget(tolua_S,1);
12629 self = (CServerSetup*) lua_touserdata(tolua_S,-1);
12630 #ifndef TOLUA_RELEASE
12631 {
12632 tolua_Error tolua_err;
12633 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12634 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
12635 }
12636 #endif
12637 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
12638 #ifndef TOLUA_RELEASE
12639 if (tolua_index<0 || tolua_index>=PlayerMax)
12640 tolua_error(tolua_S,"array indexing out of range.",NULL);
12641 #endif
12642 self->Ready[tolua_index] = ((unsigned) tolua_tonumber(tolua_S,3,0));
12643 return 0;
12644 }
12645 #endif //#ifndef TOLUA_DISABLE
12646
12647 /* get function: LastFrame of class CServerSetup */
12648 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CServerSetup_LastFrame
12649 static int tolua_get_stratagus_CServerSetup_LastFrame(lua_State* tolua_S)
12650 {
12651 int tolua_index;
12652 CServerSetup* self;
12653 lua_pushstring(tolua_S,".self");
12654 lua_rawget(tolua_S,1);
12655 self = (CServerSetup*) lua_touserdata(tolua_S,-1);
12656 #ifndef TOLUA_RELEASE
12657 {
12658 tolua_Error tolua_err;
12659 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12660 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
12661 }
12662 #endif
12663 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
12664 #ifndef TOLUA_RELEASE
12665 if (tolua_index<0 || tolua_index>=PlayerMax)
12666 tolua_error(tolua_S,"array indexing out of range.",NULL);
12667 #endif
12668 tolua_pushnumber(tolua_S,(lua_Number)self->LastFrame[tolua_index]);
12669 return 1;
12670 }
12671 #endif //#ifndef TOLUA_DISABLE
12672
12673 /* set function: LastFrame of class CServerSetup */
12674 #ifndef TOLUA_DISABLE_tolua_set_stratagus_CServerSetup_LastFrame
12675 static int tolua_set_stratagus_CServerSetup_LastFrame(lua_State* tolua_S)
12676 {
12677 int tolua_index;
12678 CServerSetup* self;
12679 lua_pushstring(tolua_S,".self");
12680 lua_rawget(tolua_S,1);
12681 self = (CServerSetup*) lua_touserdata(tolua_S,-1);
12682 #ifndef TOLUA_RELEASE
12683 {
12684 tolua_Error tolua_err;
12685 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12686 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
12687 }
12688 #endif
12689 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
12690 #ifndef TOLUA_RELEASE
12691 if (tolua_index<0 || tolua_index>=PlayerMax)
12692 tolua_error(tolua_S,"array indexing out of range.",NULL);
12693 #endif
12694 self->LastFrame[tolua_index] = ((unsigned long) tolua_tonumber(tolua_S,3,0));
12695 return 0;
12696 }
12697 #endif //#ifndef TOLUA_DISABLE
12698
12699 /* get function: LocalSetupState */
12700 #ifndef TOLUA_DISABLE_tolua_get_LocalSetupState
12701 static int tolua_get_LocalSetupState(lua_State* tolua_S)
12702 {
12703 tolua_pushusertype(tolua_S,(void*)&LocalSetupState,"CServerSetup");
12704 return 1;
12705 }
12706 #endif //#ifndef TOLUA_DISABLE
12707
12708 /* set function: LocalSetupState */
12709 #ifndef TOLUA_DISABLE_tolua_set_LocalSetupState
12710 static int tolua_set_LocalSetupState(lua_State* tolua_S)
12711 {
12712 #ifndef TOLUA_RELEASE
12713 tolua_Error tolua_err;
12714 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CServerSetup",0,&tolua_err)))
12715 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12716 #endif
12717 LocalSetupState = *((CServerSetup*) tolua_tousertype(tolua_S,2,0))
12718 ;
12719 return 0;
12720 }
12721 #endif //#ifndef TOLUA_DISABLE
12722
12723 /* get function: ServerSetupState */
12724 #ifndef TOLUA_DISABLE_tolua_get_ServerSetupState
12725 static int tolua_get_ServerSetupState(lua_State* tolua_S)
12726 {
12727 tolua_pushusertype(tolua_S,(void*)&ServerSetupState,"CServerSetup");
12728 return 1;
12729 }
12730 #endif //#ifndef TOLUA_DISABLE
12731
12732 /* set function: ServerSetupState */
12733 #ifndef TOLUA_DISABLE_tolua_set_ServerSetupState
12734 static int tolua_set_ServerSetupState(lua_State* tolua_S)
12735 {
12736 #ifndef TOLUA_RELEASE
12737 tolua_Error tolua_err;
12738 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CServerSetup",0,&tolua_err)))
12739 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12740 #endif
12741 ServerSetupState = *((CServerSetup*) tolua_tousertype(tolua_S,2,0))
12742 ;
12743 return 0;
12744 }
12745 #endif //#ifndef TOLUA_DISABLE
12746
12747 /* get function: NetLocalHostsSlot */
12748 #ifndef TOLUA_DISABLE_tolua_get_NetLocalHostsSlot
12749 static int tolua_get_NetLocalHostsSlot(lua_State* tolua_S)
12750 {
12751 tolua_pushnumber(tolua_S,(lua_Number)NetLocalHostsSlot);
12752 return 1;
12753 }
12754 #endif //#ifndef TOLUA_DISABLE
12755
12756 /* set function: NetLocalHostsSlot */
12757 #ifndef TOLUA_DISABLE_tolua_set_NetLocalHostsSlot
12758 static int tolua_set_NetLocalHostsSlot(lua_State* tolua_S)
12759 {
12760 #ifndef TOLUA_RELEASE
12761 tolua_Error tolua_err;
12762 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12763 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12764 #endif
12765 NetLocalHostsSlot = ((int) tolua_tonumber(tolua_S,2,0))
12766 ;
12767 return 0;
12768 }
12769 #endif //#ifndef TOLUA_DISABLE
12770
12771 /* get function: NetPlayerNameSize */
12772 #ifndef TOLUA_DISABLE_tolua_get_NetPlayerNameSize
12773 static int tolua_get_NetPlayerNameSize(lua_State* tolua_S)
12774 {
12775 tolua_pushnumber(tolua_S,(lua_Number)NetPlayerNameSize);
12776 return 1;
12777 }
12778 #endif //#ifndef TOLUA_DISABLE
12779
12780 /* get function: Host of class CNetworkHost */
12781 #ifndef TOLUA_DISABLE_tolua_get_CNetworkHost_unsigned_Host
12782 static int tolua_get_CNetworkHost_unsigned_Host(lua_State* tolua_S)
12783 {
12784 CNetworkHost* self = (CNetworkHost*) tolua_tousertype(tolua_S,1,0);
12785 #ifndef TOLUA_RELEASE
12786 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Host'",NULL);
12787 #endif
12788 tolua_pushnumber(tolua_S,(lua_Number)self->Host);
12789 return 1;
12790 }
12791 #endif //#ifndef TOLUA_DISABLE
12792
12793 /* set function: Host of class CNetworkHost */
12794 #ifndef TOLUA_DISABLE_tolua_set_CNetworkHost_unsigned_Host
12795 static int tolua_set_CNetworkHost_unsigned_Host(lua_State* tolua_S)
12796 {
12797 CNetworkHost* self = (CNetworkHost*) tolua_tousertype(tolua_S,1,0);
12798 #ifndef TOLUA_RELEASE
12799 tolua_Error tolua_err;
12800 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Host'",NULL);
12801 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12802 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12803 #endif
12804 self->Host = ((unsigned long) tolua_tonumber(tolua_S,2,0))
12805 ;
12806 return 0;
12807 }
12808 #endif //#ifndef TOLUA_DISABLE
12809
12810 /* get function: Port of class CNetworkHost */
12811 #ifndef TOLUA_DISABLE_tolua_get_CNetworkHost_unsigned_Port
12812 static int tolua_get_CNetworkHost_unsigned_Port(lua_State* tolua_S)
12813 {
12814 CNetworkHost* self = (CNetworkHost*) tolua_tousertype(tolua_S,1,0);
12815 #ifndef TOLUA_RELEASE
12816 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Port'",NULL);
12817 #endif
12818 tolua_pushnumber(tolua_S,(lua_Number)self->Port);
12819 return 1;
12820 }
12821 #endif //#ifndef TOLUA_DISABLE
12822
12823 /* set function: Port of class CNetworkHost */
12824 #ifndef TOLUA_DISABLE_tolua_set_CNetworkHost_unsigned_Port
12825 static int tolua_set_CNetworkHost_unsigned_Port(lua_State* tolua_S)
12826 {
12827 CNetworkHost* self = (CNetworkHost*) tolua_tousertype(tolua_S,1,0);
12828 #ifndef TOLUA_RELEASE
12829 tolua_Error tolua_err;
12830 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Port'",NULL);
12831 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12832 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12833 #endif
12834 self->Port = ((unsigned short) tolua_tonumber(tolua_S,2,0))
12835 ;
12836 return 0;
12837 }
12838 #endif //#ifndef TOLUA_DISABLE
12839
12840 /* get function: PlyNr of class CNetworkHost */
12841 #ifndef TOLUA_DISABLE_tolua_get_CNetworkHost_unsigned_PlyNr
12842 static int tolua_get_CNetworkHost_unsigned_PlyNr(lua_State* tolua_S)
12843 {
12844 CNetworkHost* self = (CNetworkHost*) tolua_tousertype(tolua_S,1,0);
12845 #ifndef TOLUA_RELEASE
12846 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PlyNr'",NULL);
12847 #endif
12848 tolua_pushnumber(tolua_S,(lua_Number)self->PlyNr);
12849 return 1;
12850 }
12851 #endif //#ifndef TOLUA_DISABLE
12852
12853 /* set function: PlyNr of class CNetworkHost */
12854 #ifndef TOLUA_DISABLE_tolua_set_CNetworkHost_unsigned_PlyNr
12855 static int tolua_set_CNetworkHost_unsigned_PlyNr(lua_State* tolua_S)
12856 {
12857 CNetworkHost* self = (CNetworkHost*) tolua_tousertype(tolua_S,1,0);
12858 #ifndef TOLUA_RELEASE
12859 tolua_Error tolua_err;
12860 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PlyNr'",NULL);
12861 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12862 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12863 #endif
12864 self->PlyNr = ((unsigned short) tolua_tonumber(tolua_S,2,0))
12865 ;
12866 return 0;
12867 }
12868 #endif //#ifndef TOLUA_DISABLE
12869
12870 /* get function: PlyName of class CNetworkHost */
12871 #ifndef TOLUA_DISABLE_tolua_get_CNetworkHost_PlyName
12872 static int tolua_get_CNetworkHost_PlyName(lua_State* tolua_S)
12873 {
12874 CNetworkHost* self = (CNetworkHost*) tolua_tousertype(tolua_S,1,0);
12875 #ifndef TOLUA_RELEASE
12876 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PlyName'",NULL);
12877 #endif
12878 tolua_pushstring(tolua_S,(const char*)self->PlyName);
12879 return 1;
12880 }
12881 #endif //#ifndef TOLUA_DISABLE
12882
12883 /* set function: PlyName of class CNetworkHost */
12884 #ifndef TOLUA_DISABLE_tolua_set_CNetworkHost_PlyName
12885 static int tolua_set_CNetworkHost_PlyName(lua_State* tolua_S)
12886 {
12887 CNetworkHost* self = (CNetworkHost*) tolua_tousertype(tolua_S,1,0);
12888 #ifndef TOLUA_RELEASE
12889 tolua_Error tolua_err;
12890 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PlyName'",NULL);
12891 if (!tolua_istable(tolua_S,2,0,&tolua_err))
12892 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12893 #endif
12894 strncpy((char*)
12895 self->PlyName,(const char*)tolua_tostring(tolua_S,2,0),NetPlayerNameSize-1);
12896 return 0;
12897 }
12898 #endif //#ifndef TOLUA_DISABLE
12899
12900 /* get function: Hosts */
12901 #ifndef TOLUA_DISABLE_tolua_get_stratagus_Hosts
12902 static int tolua_get_stratagus_Hosts(lua_State* tolua_S)
12903 {
12904 int tolua_index;
12905 #ifndef TOLUA_RELEASE
12906 {
12907 tolua_Error tolua_err;
12908 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12909 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
12910 }
12911 #endif
12912 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
12913 #ifndef TOLUA_RELEASE
12914 if (tolua_index<0 || tolua_index>=PlayerMax)
12915 tolua_error(tolua_S,"array indexing out of range.",NULL);
12916 #endif
12917 tolua_pushusertype(tolua_S,(void*)&Hosts[tolua_index],"CNetworkHost");
12918 return 1;
12919 }
12920 #endif //#ifndef TOLUA_DISABLE
12921
12922 /* set function: Hosts */
12923 #ifndef TOLUA_DISABLE_tolua_set_stratagus_Hosts
12924 static int tolua_set_stratagus_Hosts(lua_State* tolua_S)
12925 {
12926 int tolua_index;
12927 #ifndef TOLUA_RELEASE
12928 {
12929 tolua_Error tolua_err;
12930 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
12931 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
12932 }
12933 #endif
12934 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
12935 #ifndef TOLUA_RELEASE
12936 if (tolua_index<0 || tolua_index>=PlayerMax)
12937 tolua_error(tolua_S,"array indexing out of range.",NULL);
12938 #endif
12939 Hosts[tolua_index] = *((CNetworkHost*) tolua_tousertype(tolua_S,3,0));
12940 return 0;
12941 }
12942 #endif //#ifndef TOLUA_DISABLE
12943
12944 /* get function: NetworkMapName */
12945 #ifndef TOLUA_DISABLE_tolua_get_NetworkMapName
12946 static int tolua_get_NetworkMapName(lua_State* tolua_S)
12947 {
12948 tolua_pushcppstring(tolua_S,(const char*)NetworkMapName);
12949 return 1;
12950 }
12951 #endif //#ifndef TOLUA_DISABLE
12952
12953 /* set function: NetworkMapName */
12954 #ifndef TOLUA_DISABLE_tolua_set_NetworkMapName
12955 static int tolua_set_NetworkMapName(lua_State* tolua_S)
12956 {
12957 #ifndef TOLUA_RELEASE
12958 tolua_Error tolua_err;
12959 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
12960 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
12961 #endif
12962 NetworkMapName = ((string) tolua_tocppstring(tolua_S,2,0))
12963 ;
12964 return 0;
12965 }
12966 #endif //#ifndef TOLUA_DISABLE
12967
12968 /* function: NetworkGamePrepareGameSettings */
12969 #ifndef TOLUA_DISABLE_tolua_stratagus_NetworkGamePrepareGameSettings00
12970 static int tolua_stratagus_NetworkGamePrepareGameSettings00(lua_State* tolua_S)
12971 {
12972 #ifndef TOLUA_RELEASE
12973 tolua_Error tolua_err;
12974 if (
12975 !tolua_isnoobj(tolua_S,1,&tolua_err)
12976 )
12977 goto tolua_lerror;
12978 else
12979 #endif
12980 {
12981 {
12982 NetworkGamePrepareGameSettings();
12983 }
12984 }
12985 return 0;
12986 #ifndef TOLUA_RELEASE
12987 tolua_lerror:
12988 tolua_error(tolua_S,"#ferror in function 'NetworkGamePrepareGameSettings'.",&tolua_err);
12989 return 0;
12990 #endif
12991 }
12992 #endif //#ifndef TOLUA_DISABLE
12993
12994 /* function: InitVideo */
12995 #ifndef TOLUA_DISABLE_tolua_stratagus_InitVideo00
12996 static int tolua_stratagus_InitVideo00(lua_State* tolua_S)
12997 {
12998 #ifndef TOLUA_RELEASE
12999 tolua_Error tolua_err;
13000 if (
13001 !tolua_isnoobj(tolua_S,1,&tolua_err)
13002 )
13003 goto tolua_lerror;
13004 else
13005 #endif
13006 {
13007 {
13008 InitVideo();
13009 }
13010 }
13011 return 0;
13012 #ifndef TOLUA_RELEASE
13013 tolua_lerror:
13014 tolua_error(tolua_S,"#ferror in function 'InitVideo'.",&tolua_err);
13015 return 0;
13016 #endif
13017 }
13018 #endif //#ifndef TOLUA_DISABLE
13019
13020 /* get function: UseOpenGL */
13021 #ifndef TOLUA_DISABLE_tolua_get_UseOpenGL
13022 static int tolua_get_UseOpenGL(lua_State* tolua_S)
13023 {
13024 tolua_pushboolean(tolua_S,(bool)UseOpenGL);
13025 return 1;
13026 }
13027 #endif //#ifndef TOLUA_DISABLE
13028
13029 /* set function: UseOpenGL */
13030 #ifndef TOLUA_DISABLE_tolua_set_UseOpenGL
13031 static int tolua_set_UseOpenGL(lua_State* tolua_S)
13032 {
13033 #ifndef TOLUA_RELEASE
13034 tolua_Error tolua_err;
13035 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
13036 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13037 #endif
13038 UseOpenGL = ((bool) tolua_toboolean(tolua_S,2,0))
13039 ;
13040 return 0;
13041 }
13042 #endif //#ifndef TOLUA_DISABLE
13043
13044 /* get function: Width of class CVideo */
13045 #ifndef TOLUA_DISABLE_tolua_get_CVideo_Width
13046 static int tolua_get_CVideo_Width(lua_State* tolua_S)
13047 {
13048 CVideo* self = (CVideo*) tolua_tousertype(tolua_S,1,0);
13049 #ifndef TOLUA_RELEASE
13050 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Width'",NULL);
13051 #endif
13052 tolua_pushnumber(tolua_S,(lua_Number)self->Width);
13053 return 1;
13054 }
13055 #endif //#ifndef TOLUA_DISABLE
13056
13057 /* set function: Width of class CVideo */
13058 #ifndef TOLUA_DISABLE_tolua_set_CVideo_Width
13059 static int tolua_set_CVideo_Width(lua_State* tolua_S)
13060 {
13061 CVideo* self = (CVideo*) tolua_tousertype(tolua_S,1,0);
13062 #ifndef TOLUA_RELEASE
13063 tolua_Error tolua_err;
13064 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Width'",NULL);
13065 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13066 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13067 #endif
13068 self->Width = ((int) tolua_tonumber(tolua_S,2,0))
13069 ;
13070 return 0;
13071 }
13072 #endif //#ifndef TOLUA_DISABLE
13073
13074 /* get function: Height of class CVideo */
13075 #ifndef TOLUA_DISABLE_tolua_get_CVideo_Height
13076 static int tolua_get_CVideo_Height(lua_State* tolua_S)
13077 {
13078 CVideo* self = (CVideo*) tolua_tousertype(tolua_S,1,0);
13079 #ifndef TOLUA_RELEASE
13080 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Height'",NULL);
13081 #endif
13082 tolua_pushnumber(tolua_S,(lua_Number)self->Height);
13083 return 1;
13084 }
13085 #endif //#ifndef TOLUA_DISABLE
13086
13087 /* set function: Height of class CVideo */
13088 #ifndef TOLUA_DISABLE_tolua_set_CVideo_Height
13089 static int tolua_set_CVideo_Height(lua_State* tolua_S)
13090 {
13091 CVideo* self = (CVideo*) tolua_tousertype(tolua_S,1,0);
13092 #ifndef TOLUA_RELEASE
13093 tolua_Error tolua_err;
13094 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Height'",NULL);
13095 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13096 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13097 #endif
13098 self->Height = ((int) tolua_tonumber(tolua_S,2,0))
13099 ;
13100 return 0;
13101 }
13102 #endif //#ifndef TOLUA_DISABLE
13103
13104 /* get function: Depth of class CVideo */
13105 #ifndef TOLUA_DISABLE_tolua_get_CVideo_Depth
13106 static int tolua_get_CVideo_Depth(lua_State* tolua_S)
13107 {
13108 CVideo* self = (CVideo*) tolua_tousertype(tolua_S,1,0);
13109 #ifndef TOLUA_RELEASE
13110 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Depth'",NULL);
13111 #endif
13112 tolua_pushnumber(tolua_S,(lua_Number)self->Depth);
13113 return 1;
13114 }
13115 #endif //#ifndef TOLUA_DISABLE
13116
13117 /* set function: Depth of class CVideo */
13118 #ifndef TOLUA_DISABLE_tolua_set_CVideo_Depth
13119 static int tolua_set_CVideo_Depth(lua_State* tolua_S)
13120 {
13121 CVideo* self = (CVideo*) tolua_tousertype(tolua_S,1,0);
13122 #ifndef TOLUA_RELEASE
13123 tolua_Error tolua_err;
13124 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Depth'",NULL);
13125 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13126 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13127 #endif
13128 self->Depth = ((int) tolua_tonumber(tolua_S,2,0))
13129 ;
13130 return 0;
13131 }
13132 #endif //#ifndef TOLUA_DISABLE
13133
13134 /* get function: FullScreen of class CVideo */
13135 #ifndef TOLUA_DISABLE_tolua_get_CVideo_FullScreen
13136 static int tolua_get_CVideo_FullScreen(lua_State* tolua_S)
13137 {
13138 CVideo* self = (CVideo*) tolua_tousertype(tolua_S,1,0);
13139 #ifndef TOLUA_RELEASE
13140 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FullScreen'",NULL);
13141 #endif
13142 tolua_pushboolean(tolua_S,(bool)self->FullScreen);
13143 return 1;
13144 }
13145 #endif //#ifndef TOLUA_DISABLE
13146
13147 /* set function: FullScreen of class CVideo */
13148 #ifndef TOLUA_DISABLE_tolua_set_CVideo_FullScreen
13149 static int tolua_set_CVideo_FullScreen(lua_State* tolua_S)
13150 {
13151 CVideo* self = (CVideo*) tolua_tousertype(tolua_S,1,0);
13152 #ifndef TOLUA_RELEASE
13153 tolua_Error tolua_err;
13154 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FullScreen'",NULL);
13155 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
13156 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13157 #endif
13158 self->FullScreen = ((bool) tolua_toboolean(tolua_S,2,0))
13159 ;
13160 return 0;
13161 }
13162 #endif //#ifndef TOLUA_DISABLE
13163
13164 /* method: ResizeScreen of class CVideo */
13165 #ifndef TOLUA_DISABLE_tolua_stratagus_CVideo_ResizeScreen00
13166 static int tolua_stratagus_CVideo_ResizeScreen00(lua_State* tolua_S)
13167 {
13168 #ifndef TOLUA_RELEASE
13169 tolua_Error tolua_err;
13170 if (
13171 !tolua_isusertype(tolua_S,1,"CVideo",0,&tolua_err) ||
13172 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
13173 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
13174 !tolua_isnoobj(tolua_S,4,&tolua_err)
13175 )
13176 goto tolua_lerror;
13177 else
13178 #endif
13179 {
13180 CVideo* self = (CVideo*) tolua_tousertype(tolua_S,1,0);
13181 int width = ((int) tolua_tonumber(tolua_S,2,0));
13182 int height = ((int) tolua_tonumber(tolua_S,3,0));
13183 #ifndef TOLUA_RELEASE
13184 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ResizeScreen'", NULL);
13185 #endif
13186 {
13187 bool tolua_ret = (bool) self->ResizeScreen(width,height);
13188 tolua_pushboolean(tolua_S,(bool)tolua_ret);
13189 }
13190 }
13191 return 1;
13192 #ifndef TOLUA_RELEASE
13193 tolua_lerror:
13194 tolua_error(tolua_S,"#ferror in function 'ResizeScreen'.",&tolua_err);
13195 return 0;
13196 #endif
13197 }
13198 #endif //#ifndef TOLUA_DISABLE
13199
13200 /* get function: Video */
13201 #ifndef TOLUA_DISABLE_tolua_get_Video
13202 static int tolua_get_Video(lua_State* tolua_S)
13203 {
13204 tolua_pushusertype(tolua_S,(void*)&Video,"CVideo");
13205 return 1;
13206 }
13207 #endif //#ifndef TOLUA_DISABLE
13208
13209 /* set function: Video */
13210 #ifndef TOLUA_DISABLE_tolua_set_Video
13211 static int tolua_set_Video(lua_State* tolua_S)
13212 {
13213 #ifndef TOLUA_RELEASE
13214 tolua_Error tolua_err;
13215 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CVideo",0,&tolua_err)))
13216 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13217 #endif
13218 Video = *((CVideo*) tolua_tousertype(tolua_S,2,0))
13219 ;
13220 return 0;
13221 }
13222 #endif //#ifndef TOLUA_DISABLE
13223
13224 /* function: ToggleFullScreen */
13225 #ifndef TOLUA_DISABLE_tolua_stratagus_ToggleFullScreen00
13226 static int tolua_stratagus_ToggleFullScreen00(lua_State* tolua_S)
13227 {
13228 #ifndef TOLUA_RELEASE
13229 tolua_Error tolua_err;
13230 if (
13231 !tolua_isnoobj(tolua_S,1,&tolua_err)
13232 )
13233 goto tolua_lerror;
13234 else
13235 #endif
13236 {
13237 {
13238 ToggleFullScreen();
13239 }
13240 }
13241 return 0;
13242 #ifndef TOLUA_RELEASE
13243 tolua_lerror:
13244 tolua_error(tolua_S,"#ferror in function 'ToggleFullScreen'.",&tolua_err);
13245 return 0;
13246 #endif
13247 }
13248 #endif //#ifndef TOLUA_DISABLE
13249
13250 /* method: New of class CGraphic */
13251 #ifndef TOLUA_DISABLE_tolua_stratagus_CGraphic_New00
13252 static int tolua_stratagus_CGraphic_New00(lua_State* tolua_S)
13253 {
13254 #ifndef TOLUA_RELEASE
13255 tolua_Error tolua_err;
13256 if (
13257 !tolua_isusertable(tolua_S,1,"CGraphic",0,&tolua_err) ||
13258 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
13259 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
13260 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
13261 !tolua_isnoobj(tolua_S,5,&tolua_err)
13262 )
13263 goto tolua_lerror;
13264 else
13265 #endif
13266 {
13267 const std::string file = ((const std::string) tolua_tocppstring(tolua_S,2,0));
13268 int w = ((int) tolua_tonumber(tolua_S,3,0));
13269 int h = ((int) tolua_tonumber(tolua_S,4,0));
13270 {
13271 CGraphic* tolua_ret = (CGraphic*) CGraphic::New(file,w,h);
13272 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CGraphic");
13273 }
13274 }
13275 return 1;
13276 #ifndef TOLUA_RELEASE
13277 tolua_lerror:
13278 tolua_error(tolua_S,"#ferror in function 'New'.",&tolua_err);
13279 return 0;
13280 #endif
13281 }
13282 #endif //#ifndef TOLUA_DISABLE
13283
13284 /* method: Free of class CGraphic */
13285 #ifndef TOLUA_DISABLE_tolua_stratagus_CGraphic_Free00
13286 static int tolua_stratagus_CGraphic_Free00(lua_State* tolua_S)
13287 {
13288 #ifndef TOLUA_RELEASE
13289 tolua_Error tolua_err;
13290 if (
13291 !tolua_isusertable(tolua_S,1,"CGraphic",0,&tolua_err) ||
13292 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
13293 !tolua_isnoobj(tolua_S,3,&tolua_err)
13294 )
13295 goto tolua_lerror;
13296 else
13297 #endif
13298 {
13299 CGraphic* tolua_var_1 = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
13300 {
13301 CGraphic::Free(tolua_var_1);
13302 }
13303 }
13304 return 0;
13305 #ifndef TOLUA_RELEASE
13306 tolua_lerror:
13307 tolua_error(tolua_S,"#ferror in function 'Free'.",&tolua_err);
13308 return 0;
13309 #endif
13310 }
13311 #endif //#ifndef TOLUA_DISABLE
13312
13313 /* method: Load of class CGraphic */
13314 #ifndef TOLUA_DISABLE_tolua_stratagus_CGraphic_Load00
13315 static int tolua_stratagus_CGraphic_Load00(lua_State* tolua_S)
13316 {
13317 #ifndef TOLUA_RELEASE
13318 tolua_Error tolua_err;
13319 if (
13320 !tolua_isusertype(tolua_S,1,"CGraphic",0,&tolua_err) ||
13321 !tolua_isnoobj(tolua_S,2,&tolua_err)
13322 )
13323 goto tolua_lerror;
13324 else
13325 #endif
13326 {
13327 CGraphic* self = (CGraphic*) tolua_tousertype(tolua_S,1,0);
13328 #ifndef TOLUA_RELEASE
13329 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Load'", NULL);
13330 #endif
13331 {
13332 self->Load();
13333 }
13334 }
13335 return 0;
13336 #ifndef TOLUA_RELEASE
13337 tolua_lerror:
13338 tolua_error(tolua_S,"#ferror in function 'Load'.",&tolua_err);
13339 return 0;
13340 #endif
13341 }
13342 #endif //#ifndef TOLUA_DISABLE
13343
13344 /* method: Resize of class CGraphic */
13345 #ifndef TOLUA_DISABLE_tolua_stratagus_CGraphic_Resize00
13346 static int tolua_stratagus_CGraphic_Resize00(lua_State* tolua_S)
13347 {
13348 #ifndef TOLUA_RELEASE
13349 tolua_Error tolua_err;
13350 if (
13351 !tolua_isusertype(tolua_S,1,"CGraphic",0,&tolua_err) ||
13352 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
13353 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
13354 !tolua_isnoobj(tolua_S,4,&tolua_err)
13355 )
13356 goto tolua_lerror;
13357 else
13358 #endif
13359 {
13360 CGraphic* self = (CGraphic*) tolua_tousertype(tolua_S,1,0);
13361 int w = ((int) tolua_tonumber(tolua_S,2,0));
13362 int h = ((int) tolua_tonumber(tolua_S,3,0));
13363 #ifndef TOLUA_RELEASE
13364 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Resize'", NULL);
13365 #endif
13366 {
13367 self->Resize(w,h);
13368 }
13369 }
13370 return 0;
13371 #ifndef TOLUA_RELEASE
13372 tolua_lerror:
13373 tolua_error(tolua_S,"#ferror in function 'Resize'.",&tolua_err);
13374 return 0;
13375 #endif
13376 }
13377 #endif //#ifndef TOLUA_DISABLE
13378
13379 /* method: New of class CPlayerColorGraphic */
13380 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayerColorGraphic_New00
13381 static int tolua_stratagus_CPlayerColorGraphic_New00(lua_State* tolua_S)
13382 {
13383 #ifndef TOLUA_RELEASE
13384 tolua_Error tolua_err;
13385 if (
13386 !tolua_isusertable(tolua_S,1,"CPlayerColorGraphic",0,&tolua_err) ||
13387 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
13388 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
13389 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
13390 !tolua_isnoobj(tolua_S,5,&tolua_err)
13391 )
13392 goto tolua_lerror;
13393 else
13394 #endif
13395 {
13396 const std::string file = ((const std::string) tolua_tocppstring(tolua_S,2,0));
13397 int w = ((int) tolua_tonumber(tolua_S,3,0));
13398 int h = ((int) tolua_tonumber(tolua_S,4,0));
13399 {
13400 CPlayerColorGraphic* tolua_ret = (CPlayerColorGraphic*) CPlayerColorGraphic::New(file,w,h);
13401 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CPlayerColorGraphic");
13402 }
13403 }
13404 return 1;
13405 #ifndef TOLUA_RELEASE
13406 tolua_lerror:
13407 tolua_error(tolua_S,"#ferror in function 'New'.",&tolua_err);
13408 return 0;
13409 #endif
13410 }
13411 #endif //#ifndef TOLUA_DISABLE
13412
13413 /* method: new of class CColor */
13414 #ifndef TOLUA_DISABLE_tolua_stratagus_CColor_new00
13415 static int tolua_stratagus_CColor_new00(lua_State* tolua_S)
13416 {
13417 #ifndef TOLUA_RELEASE
13418 tolua_Error tolua_err;
13419 if (
13420 !tolua_isusertable(tolua_S,1,"CColor",0,&tolua_err) ||
13421 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
13422 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
13423 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
13424 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
13425 !tolua_isnoobj(tolua_S,6,&tolua_err)
13426 )
13427 goto tolua_lerror;
13428 else
13429 #endif
13430 {
13431 unsigned char r = ((unsigned char) tolua_tonumber(tolua_S,2,0));
13432 unsigned char g = ((unsigned char) tolua_tonumber(tolua_S,3,0));
13433 unsigned char b = ((unsigned char) tolua_tonumber(tolua_S,4,0));
13434 unsigned char a = ((unsigned char) tolua_tonumber(tolua_S,5,0));
13435 {
13436 CColor* tolua_ret = (CColor*) Mtolua_new((CColor)(r,g,b,a));
13437 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CColor");
13438 }
13439 }
13440 return 1;
13441 #ifndef TOLUA_RELEASE
13442 tolua_lerror:
13443 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
13444 return 0;
13445 #endif
13446 }
13447 #endif //#ifndef TOLUA_DISABLE
13448
13449 /* method: new_local of class CColor */
13450 #ifndef TOLUA_DISABLE_tolua_stratagus_CColor_new00_local
13451 static int tolua_stratagus_CColor_new00_local(lua_State* tolua_S)
13452 {
13453 #ifndef TOLUA_RELEASE
13454 tolua_Error tolua_err;
13455 if (
13456 !tolua_isusertable(tolua_S,1,"CColor",0,&tolua_err) ||
13457 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
13458 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
13459 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
13460 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
13461 !tolua_isnoobj(tolua_S,6,&tolua_err)
13462 )
13463 goto tolua_lerror;
13464 else
13465 #endif
13466 {
13467 unsigned char r = ((unsigned char) tolua_tonumber(tolua_S,2,0));
13468 unsigned char g = ((unsigned char) tolua_tonumber(tolua_S,3,0));
13469 unsigned char b = ((unsigned char) tolua_tonumber(tolua_S,4,0));
13470 unsigned char a = ((unsigned char) tolua_tonumber(tolua_S,5,0));
13471 {
13472 CColor* tolua_ret = (CColor*) Mtolua_new((CColor)(r,g,b,a));
13473 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CColor");
13474 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
13475 }
13476 }
13477 return 1;
13478 #ifndef TOLUA_RELEASE
13479 tolua_lerror:
13480 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
13481 return 0;
13482 #endif
13483 }
13484 #endif //#ifndef TOLUA_DISABLE
13485
13486 /* get function: R of class CColor */
13487 #ifndef TOLUA_DISABLE_tolua_get_CColor_unsigned_R
13488 static int tolua_get_CColor_unsigned_R(lua_State* tolua_S)
13489 {
13490 CColor* self = (CColor*) tolua_tousertype(tolua_S,1,0);
13491 #ifndef TOLUA_RELEASE
13492 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'R'",NULL);
13493 #endif
13494 tolua_pushnumber(tolua_S,(lua_Number)self->R);
13495 return 1;
13496 }
13497 #endif //#ifndef TOLUA_DISABLE
13498
13499 /* set function: R of class CColor */
13500 #ifndef TOLUA_DISABLE_tolua_set_CColor_unsigned_R
13501 static int tolua_set_CColor_unsigned_R(lua_State* tolua_S)
13502 {
13503 CColor* self = (CColor*) tolua_tousertype(tolua_S,1,0);
13504 #ifndef TOLUA_RELEASE
13505 tolua_Error tolua_err;
13506 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'R'",NULL);
13507 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13508 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13509 #endif
13510 self->R = ((unsigned char) tolua_tonumber(tolua_S,2,0))
13511 ;
13512 return 0;
13513 }
13514 #endif //#ifndef TOLUA_DISABLE
13515
13516 /* get function: G of class CColor */
13517 #ifndef TOLUA_DISABLE_tolua_get_CColor_unsigned_G
13518 static int tolua_get_CColor_unsigned_G(lua_State* tolua_S)
13519 {
13520 CColor* self = (CColor*) tolua_tousertype(tolua_S,1,0);
13521 #ifndef TOLUA_RELEASE
13522 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
13523 #endif
13524 tolua_pushnumber(tolua_S,(lua_Number)self->G);
13525 return 1;
13526 }
13527 #endif //#ifndef TOLUA_DISABLE
13528
13529 /* set function: G of class CColor */
13530 #ifndef TOLUA_DISABLE_tolua_set_CColor_unsigned_G
13531 static int tolua_set_CColor_unsigned_G(lua_State* tolua_S)
13532 {
13533 CColor* self = (CColor*) tolua_tousertype(tolua_S,1,0);
13534 #ifndef TOLUA_RELEASE
13535 tolua_Error tolua_err;
13536 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'G'",NULL);
13537 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13538 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13539 #endif
13540 self->G = ((unsigned char) tolua_tonumber(tolua_S,2,0))
13541 ;
13542 return 0;
13543 }
13544 #endif //#ifndef TOLUA_DISABLE
13545
13546 /* get function: B of class CColor */
13547 #ifndef TOLUA_DISABLE_tolua_get_CColor_unsigned_B
13548 static int tolua_get_CColor_unsigned_B(lua_State* tolua_S)
13549 {
13550 CColor* self = (CColor*) tolua_tousertype(tolua_S,1,0);
13551 #ifndef TOLUA_RELEASE
13552 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'B'",NULL);
13553 #endif
13554 tolua_pushnumber(tolua_S,(lua_Number)self->B);
13555 return 1;
13556 }
13557 #endif //#ifndef TOLUA_DISABLE
13558
13559 /* set function: B of class CColor */
13560 #ifndef TOLUA_DISABLE_tolua_set_CColor_unsigned_B
13561 static int tolua_set_CColor_unsigned_B(lua_State* tolua_S)
13562 {
13563 CColor* self = (CColor*) tolua_tousertype(tolua_S,1,0);
13564 #ifndef TOLUA_RELEASE
13565 tolua_Error tolua_err;
13566 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'B'",NULL);
13567 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13568 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13569 #endif
13570 self->B = ((unsigned char) tolua_tonumber(tolua_S,2,0))
13571 ;
13572 return 0;
13573 }
13574 #endif //#ifndef TOLUA_DISABLE
13575
13576 /* get function: A of class CColor */
13577 #ifndef TOLUA_DISABLE_tolua_get_CColor_unsigned_A
13578 static int tolua_get_CColor_unsigned_A(lua_State* tolua_S)
13579 {
13580 CColor* self = (CColor*) tolua_tousertype(tolua_S,1,0);
13581 #ifndef TOLUA_RELEASE
13582 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'A'",NULL);
13583 #endif
13584 tolua_pushnumber(tolua_S,(lua_Number)self->A);
13585 return 1;
13586 }
13587 #endif //#ifndef TOLUA_DISABLE
13588
13589 /* set function: A of class CColor */
13590 #ifndef TOLUA_DISABLE_tolua_set_CColor_unsigned_A
13591 static int tolua_set_CColor_unsigned_A(lua_State* tolua_S)
13592 {
13593 CColor* self = (CColor*) tolua_tousertype(tolua_S,1,0);
13594 #ifndef TOLUA_RELEASE
13595 tolua_Error tolua_err;
13596 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'A'",NULL);
13597 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13598 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13599 #endif
13600 self->A = ((unsigned char) tolua_tonumber(tolua_S,2,0))
13601 ;
13602 return 0;
13603 }
13604 #endif //#ifndef TOLUA_DISABLE
13605
13606 /* get function: UseGLTextureCompression */
13607 #ifndef TOLUA_DISABLE_tolua_get_UseGLTextureCompression
13608 static int tolua_get_UseGLTextureCompression(lua_State* tolua_S)
13609 {
13610 tolua_pushboolean(tolua_S,(bool)UseGLTextureCompression);
13611 return 1;
13612 }
13613 #endif //#ifndef TOLUA_DISABLE
13614
13615 /* set function: UseGLTextureCompression */
13616 #ifndef TOLUA_DISABLE_tolua_set_UseGLTextureCompression
13617 static int tolua_set_UseGLTextureCompression(lua_State* tolua_S)
13618 {
13619 #ifndef TOLUA_RELEASE
13620 tolua_Error tolua_err;
13621 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
13622 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13623 #endif
13624 UseGLTextureCompression = ((bool) tolua_toboolean(tolua_S,2,0))
13625 ;
13626 return 0;
13627 }
13628 #endif //#ifndef TOLUA_DISABLE
13629
13630 /* method: New of class CFont */
13631 #ifndef TOLUA_DISABLE_tolua_stratagus_CFont_New00
13632 static int tolua_stratagus_CFont_New00(lua_State* tolua_S)
13633 {
13634 #ifndef TOLUA_RELEASE
13635 tolua_Error tolua_err;
13636 if (
13637 !tolua_isusertable(tolua_S,1,"CFont",0,&tolua_err) ||
13638 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
13639 !tolua_isusertype(tolua_S,3,"CGraphic",0,&tolua_err) ||
13640 !tolua_isnoobj(tolua_S,4,&tolua_err)
13641 )
13642 goto tolua_lerror;
13643 else
13644 #endif
13645 {
13646 const std::string ident = ((const std::string) tolua_tocppstring(tolua_S,2,0));
13647 CGraphic* g = ((CGraphic*) tolua_tousertype(tolua_S,3,0));
13648 {
13649 CFont* tolua_ret = (CFont*) CFont::New(ident,g);
13650 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CFont");
13651 }
13652 }
13653 return 1;
13654 #ifndef TOLUA_RELEASE
13655 tolua_lerror:
13656 tolua_error(tolua_S,"#ferror in function 'New'.",&tolua_err);
13657 return 0;
13658 #endif
13659 }
13660 #endif //#ifndef TOLUA_DISABLE
13661
13662 /* method: Get of class CFont */
13663 #ifndef TOLUA_DISABLE_tolua_stratagus_CFont_Get00
13664 static int tolua_stratagus_CFont_Get00(lua_State* tolua_S)
13665 {
13666 #ifndef TOLUA_RELEASE
13667 tolua_Error tolua_err;
13668 if (
13669 !tolua_isusertable(tolua_S,1,"CFont",0,&tolua_err) ||
13670 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
13671 !tolua_isnoobj(tolua_S,3,&tolua_err)
13672 )
13673 goto tolua_lerror;
13674 else
13675 #endif
13676 {
13677 const std::string ident = ((const std::string) tolua_tocppstring(tolua_S,2,0));
13678 {
13679 CFont* tolua_ret = (CFont*) CFont::Get(ident);
13680 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CFont");
13681 }
13682 }
13683 return 1;
13684 #ifndef TOLUA_RELEASE
13685 tolua_lerror:
13686 tolua_error(tolua_S,"#ferror in function 'Get'.",&tolua_err);
13687 return 0;
13688 #endif
13689 }
13690 #endif //#ifndef TOLUA_DISABLE
13691
13692 /* method: Height of class CFont */
13693 #ifndef TOLUA_DISABLE_tolua_stratagus_CFont_Height00
13694 static int tolua_stratagus_CFont_Height00(lua_State* tolua_S)
13695 {
13696 #ifndef TOLUA_RELEASE
13697 tolua_Error tolua_err;
13698 if (
13699 !tolua_isusertype(tolua_S,1,"CFont",0,&tolua_err) ||
13700 !tolua_isnoobj(tolua_S,2,&tolua_err)
13701 )
13702 goto tolua_lerror;
13703 else
13704 #endif
13705 {
13706 CFont* self = (CFont*) tolua_tousertype(tolua_S,1,0);
13707 #ifndef TOLUA_RELEASE
13708 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Height'", NULL);
13709 #endif
13710 {
13711 int tolua_ret = (int) self->Height();
13712 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
13713 }
13714 }
13715 return 1;
13716 #ifndef TOLUA_RELEASE
13717 tolua_lerror:
13718 tolua_error(tolua_S,"#ferror in function 'Height'.",&tolua_err);
13719 return 0;
13720 #endif
13721 }
13722 #endif //#ifndef TOLUA_DISABLE
13723
13724 /* method: Width of class CFont */
13725 #ifndef TOLUA_DISABLE_tolua_stratagus_CFont_Width00
13726 static int tolua_stratagus_CFont_Width00(lua_State* tolua_S)
13727 {
13728 #ifndef TOLUA_RELEASE
13729 tolua_Error tolua_err;
13730 if (
13731 !tolua_isusertype(tolua_S,1,"CFont",0,&tolua_err) ||
13732 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
13733 !tolua_isnoobj(tolua_S,3,&tolua_err)
13734 )
13735 goto tolua_lerror;
13736 else
13737 #endif
13738 {
13739 CFont* self = (CFont*) tolua_tousertype(tolua_S,1,0);
13740 const std::string text = ((const std::string) tolua_tocppstring(tolua_S,2,0));
13741 #ifndef TOLUA_RELEASE
13742 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Width'", NULL);
13743 #endif
13744 {
13745 int tolua_ret = (int) self->Width(text);
13746 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
13747 }
13748 }
13749 return 1;
13750 #ifndef TOLUA_RELEASE
13751 tolua_lerror:
13752 tolua_error(tolua_S,"#ferror in function 'Width'.",&tolua_err);
13753 return 0;
13754 #endif
13755 }
13756 #endif //#ifndef TOLUA_DISABLE
13757
13758 /* method: PlainText of class CFont */
13759 #ifndef TOLUA_DISABLE_tolua_stratagus_CFont_PlainText00
13760 static int tolua_stratagus_CFont_PlainText00(lua_State* tolua_S)
13761 {
13762 #ifndef TOLUA_RELEASE
13763 tolua_Error tolua_err;
13764 if (
13765 !tolua_isusertype(tolua_S,1,"CFont",0,&tolua_err) ||
13766 !tolua_isnoobj(tolua_S,2,&tolua_err)
13767 )
13768 goto tolua_lerror;
13769 else
13770 #endif
13771 {
13772 CFont* self = (CFont*) tolua_tousertype(tolua_S,1,0);
13773 #ifndef TOLUA_RELEASE
13774 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'PlainText'", NULL);
13775 #endif
13776 {
13777 CFont* tolua_ret = (CFont*) self->PlainText();
13778 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CFont");
13779 }
13780 }
13781 return 1;
13782 #ifndef TOLUA_RELEASE
13783 tolua_lerror:
13784 tolua_error(tolua_S,"#ferror in function 'PlainText'.",&tolua_err);
13785 return 0;
13786 #endif
13787 }
13788 #endif //#ifndef TOLUA_DISABLE
13789
13790 /* method: New of class CFontColor */
13791 #ifndef TOLUA_DISABLE_tolua_stratagus_CFontColor_New00
13792 static int tolua_stratagus_CFontColor_New00(lua_State* tolua_S)
13793 {
13794 #ifndef TOLUA_RELEASE
13795 tolua_Error tolua_err;
13796 if (
13797 !tolua_isusertable(tolua_S,1,"CFontColor",0,&tolua_err) ||
13798 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
13799 !tolua_isnoobj(tolua_S,3,&tolua_err)
13800 )
13801 goto tolua_lerror;
13802 else
13803 #endif
13804 {
13805 const std::string ident = ((const std::string) tolua_tocppstring(tolua_S,2,0));
13806 {
13807 CFontColor* tolua_ret = (CFontColor*) CFontColor::New(ident);
13808 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CFontColor");
13809 }
13810 }
13811 return 1;
13812 #ifndef TOLUA_RELEASE
13813 tolua_lerror:
13814 tolua_error(tolua_S,"#ferror in function 'New'.",&tolua_err);
13815 return 0;
13816 #endif
13817 }
13818 #endif //#ifndef TOLUA_DISABLE
13819
13820 /* method: Get of class CFontColor */
13821 #ifndef TOLUA_DISABLE_tolua_stratagus_CFontColor_Get00
13822 static int tolua_stratagus_CFontColor_Get00(lua_State* tolua_S)
13823 {
13824 #ifndef TOLUA_RELEASE
13825 tolua_Error tolua_err;
13826 if (
13827 !tolua_isusertable(tolua_S,1,"CFontColor",0,&tolua_err) ||
13828 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
13829 !tolua_isnoobj(tolua_S,3,&tolua_err)
13830 )
13831 goto tolua_lerror;
13832 else
13833 #endif
13834 {
13835 const std::string ident = ((const std::string) tolua_tocppstring(tolua_S,2,0));
13836 {
13837 CFontColor* tolua_ret = (CFontColor*) CFontColor::Get(ident);
13838 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CFontColor");
13839 }
13840 }
13841 return 1;
13842 #ifndef TOLUA_RELEASE
13843 tolua_lerror:
13844 tolua_error(tolua_S,"#ferror in function 'Get'.",&tolua_err);
13845 return 0;
13846 #endif
13847 }
13848 #endif //#ifndef TOLUA_DISABLE
13849
13850 /* get function: Colors of class CFontColor */
13851 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CFontColor_Colors
13852 static int tolua_get_stratagus_CFontColor_Colors(lua_State* tolua_S)
13853 {
13854 int tolua_index;
13855 CFontColor* self;
13856 lua_pushstring(tolua_S,".self");
13857 lua_rawget(tolua_S,1);
13858 self = (CFontColor*) lua_touserdata(tolua_S,-1);
13859 #ifndef TOLUA_RELEASE
13860 {
13861 tolua_Error tolua_err;
13862 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13863 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
13864 }
13865 #endif
13866 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
13867 #ifndef TOLUA_RELEASE
13868 if (tolua_index<0 || tolua_index>=MaxFontColors)
13869 tolua_error(tolua_S,"array indexing out of range.",NULL);
13870 #endif
13871 tolua_pushusertype(tolua_S,(void*)&self->Colors[tolua_index],"CColor");
13872 return 1;
13873 }
13874 #endif //#ifndef TOLUA_DISABLE
13875
13876 /* set function: Colors of class CFontColor */
13877 #ifndef TOLUA_DISABLE_tolua_set_stratagus_CFontColor_Colors
13878 static int tolua_set_stratagus_CFontColor_Colors(lua_State* tolua_S)
13879 {
13880 int tolua_index;
13881 CFontColor* self;
13882 lua_pushstring(tolua_S,".self");
13883 lua_rawget(tolua_S,1);
13884 self = (CFontColor*) lua_touserdata(tolua_S,-1);
13885 #ifndef TOLUA_RELEASE
13886 {
13887 tolua_Error tolua_err;
13888 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13889 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
13890 }
13891 #endif
13892 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
13893 #ifndef TOLUA_RELEASE
13894 if (tolua_index<0 || tolua_index>=MaxFontColors)
13895 tolua_error(tolua_S,"array indexing out of range.",NULL);
13896 #endif
13897 self->Colors[tolua_index] = *((CColor*) tolua_tousertype(tolua_S,3,0));
13898 return 0;
13899 }
13900 #endif //#ifndef TOLUA_DISABLE
13901
13902 /* get function: Index of class CPlayer */
13903 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_Index
13904 static int tolua_get_CPlayer_Index(lua_State* tolua_S)
13905 {
13906 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
13907 #ifndef TOLUA_RELEASE
13908 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
13909 #endif
13910 tolua_pushnumber(tolua_S,(lua_Number)self->Index);
13911 return 1;
13912 }
13913 #endif //#ifndef TOLUA_DISABLE
13914
13915 /* set function: Index of class CPlayer */
13916 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_Index
13917 static int tolua_set_CPlayer_Index(lua_State* tolua_S)
13918 {
13919 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
13920 #ifndef TOLUA_RELEASE
13921 tolua_Error tolua_err;
13922 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
13923 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13924 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13925 #endif
13926 self->Index = ((int) tolua_tonumber(tolua_S,2,0))
13927 ;
13928 return 0;
13929 }
13930 #endif //#ifndef TOLUA_DISABLE
13931
13932 /* get function: Name of class CPlayer */
13933 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_Name
13934 static int tolua_get_CPlayer_Name(lua_State* tolua_S)
13935 {
13936 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
13937 #ifndef TOLUA_RELEASE
13938 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
13939 #endif
13940 tolua_pushcppstring(tolua_S,(const char*)self->Name);
13941 return 1;
13942 }
13943 #endif //#ifndef TOLUA_DISABLE
13944
13945 /* set function: Name of class CPlayer */
13946 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_Name
13947 static int tolua_set_CPlayer_Name(lua_State* tolua_S)
13948 {
13949 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
13950 #ifndef TOLUA_RELEASE
13951 tolua_Error tolua_err;
13952 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
13953 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
13954 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13955 #endif
13956 self->Name = ((string) tolua_tocppstring(tolua_S,2,0))
13957 ;
13958 return 0;
13959 }
13960 #endif //#ifndef TOLUA_DISABLE
13961
13962 /* get function: Type of class CPlayer */
13963 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_Type
13964 static int tolua_get_CPlayer_Type(lua_State* tolua_S)
13965 {
13966 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
13967 #ifndef TOLUA_RELEASE
13968 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
13969 #endif
13970 tolua_pushnumber(tolua_S,(lua_Number)self->Type);
13971 return 1;
13972 }
13973 #endif //#ifndef TOLUA_DISABLE
13974
13975 /* set function: Type of class CPlayer */
13976 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_Type
13977 static int tolua_set_CPlayer_Type(lua_State* tolua_S)
13978 {
13979 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
13980 #ifndef TOLUA_RELEASE
13981 tolua_Error tolua_err;
13982 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
13983 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
13984 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
13985 #endif
13986 self->Type = ((PlayerTypes) (int) tolua_tonumber(tolua_S,2,0))
13987 ;
13988 return 0;
13989 }
13990 #endif //#ifndef TOLUA_DISABLE
13991
13992 /* get function: AiName of class CPlayer */
13993 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_AiName
13994 static int tolua_get_CPlayer_AiName(lua_State* tolua_S)
13995 {
13996 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
13997 #ifndef TOLUA_RELEASE
13998 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AiName'",NULL);
13999 #endif
14000 tolua_pushcppstring(tolua_S,(const char*)self->AiName);
14001 return 1;
14002 }
14003 #endif //#ifndef TOLUA_DISABLE
14004
14005 /* set function: AiName of class CPlayer */
14006 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_AiName
14007 static int tolua_set_CPlayer_AiName(lua_State* tolua_S)
14008 {
14009 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14010 #ifndef TOLUA_RELEASE
14011 tolua_Error tolua_err;
14012 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AiName'",NULL);
14013 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
14014 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14015 #endif
14016 self->AiName = ((string) tolua_tocppstring(tolua_S,2,0))
14017 ;
14018 return 0;
14019 }
14020 #endif //#ifndef TOLUA_DISABLE
14021
14022 /* get function: StartX of class CPlayer */
14023 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_StartX
14024 static int tolua_get_CPlayer_StartX(lua_State* tolua_S)
14025 {
14026 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14027 #ifndef TOLUA_RELEASE
14028 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'StartX'",NULL);
14029 #endif
14030 tolua_pushnumber(tolua_S,(lua_Number)self->StartX);
14031 return 1;
14032 }
14033 #endif //#ifndef TOLUA_DISABLE
14034
14035 /* set function: StartX of class CPlayer */
14036 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_StartX
14037 static int tolua_set_CPlayer_StartX(lua_State* tolua_S)
14038 {
14039 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14040 #ifndef TOLUA_RELEASE
14041 tolua_Error tolua_err;
14042 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'StartX'",NULL);
14043 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14044 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14045 #endif
14046 self->StartX = ((int) tolua_tonumber(tolua_S,2,0))
14047 ;
14048 return 0;
14049 }
14050 #endif //#ifndef TOLUA_DISABLE
14051
14052 /* get function: StartY of class CPlayer */
14053 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_StartY
14054 static int tolua_get_CPlayer_StartY(lua_State* tolua_S)
14055 {
14056 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14057 #ifndef TOLUA_RELEASE
14058 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'StartY'",NULL);
14059 #endif
14060 tolua_pushnumber(tolua_S,(lua_Number)self->StartY);
14061 return 1;
14062 }
14063 #endif //#ifndef TOLUA_DISABLE
14064
14065 /* set function: StartY of class CPlayer */
14066 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_StartY
14067 static int tolua_set_CPlayer_StartY(lua_State* tolua_S)
14068 {
14069 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14070 #ifndef TOLUA_RELEASE
14071 tolua_Error tolua_err;
14072 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'StartY'",NULL);
14073 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14074 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14075 #endif
14076 self->StartY = ((int) tolua_tonumber(tolua_S,2,0))
14077 ;
14078 return 0;
14079 }
14080 #endif //#ifndef TOLUA_DISABLE
14081
14082 /* method: SetStartView of class CPlayer */
14083 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_SetStartView00
14084 static int tolua_stratagus_CPlayer_SetStartView00(lua_State* tolua_S)
14085 {
14086 #ifndef TOLUA_RELEASE
14087 tolua_Error tolua_err;
14088 if (
14089 !tolua_isusertype(tolua_S,1,"CPlayer",0,&tolua_err) ||
14090 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
14091 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
14092 !tolua_isnoobj(tolua_S,4,&tolua_err)
14093 )
14094 goto tolua_lerror;
14095 else
14096 #endif
14097 {
14098 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14099 int x = ((int) tolua_tonumber(tolua_S,2,0));
14100 int y = ((int) tolua_tonumber(tolua_S,3,0));
14101 #ifndef TOLUA_RELEASE
14102 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetStartView'", NULL);
14103 #endif
14104 {
14105 self->SetStartView(x,y);
14106 }
14107 }
14108 return 0;
14109 #ifndef TOLUA_RELEASE
14110 tolua_lerror:
14111 tolua_error(tolua_S,"#ferror in function 'SetStartView'.",&tolua_err);
14112 return 0;
14113 #endif
14114 }
14115 #endif //#ifndef TOLUA_DISABLE
14116
14117 /* get function: EnergyProductionRate of class CPlayer */
14118 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_EnergyProductionRate
14119 static int tolua_get_CPlayer_EnergyProductionRate(lua_State* tolua_S)
14120 {
14121 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14122 #ifndef TOLUA_RELEASE
14123 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyProductionRate'",NULL);
14124 #endif
14125 tolua_pushnumber(tolua_S,(lua_Number)self->GetEnergyProductionRate());
14126 return 1;
14127 }
14128 #endif //#ifndef TOLUA_DISABLE
14129
14130 /* set function: EnergyProductionRate of class CPlayer */
14131 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_EnergyProductionRate
14132 static int tolua_set_CPlayer_EnergyProductionRate(lua_State* tolua_S)
14133 {
14134 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14135 #ifndef TOLUA_RELEASE
14136 tolua_Error tolua_err;
14137 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyProductionRate'",NULL);
14138 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14139 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14140 #endif
14141 self->SetEnergyProductionRate(((int) tolua_tonumber(tolua_S,2,0))
14142 )
14143 ;
14144 return 0;
14145 }
14146 #endif //#ifndef TOLUA_DISABLE
14147
14148 /* get function: MagmaProductionRate of class CPlayer */
14149 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_MagmaProductionRate
14150 static int tolua_get_CPlayer_MagmaProductionRate(lua_State* tolua_S)
14151 {
14152 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14153 #ifndef TOLUA_RELEASE
14154 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaProductionRate'",NULL);
14155 #endif
14156 tolua_pushnumber(tolua_S,(lua_Number)self->GetMagmaProductionRate());
14157 return 1;
14158 }
14159 #endif //#ifndef TOLUA_DISABLE
14160
14161 /* set function: MagmaProductionRate of class CPlayer */
14162 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_MagmaProductionRate
14163 static int tolua_set_CPlayer_MagmaProductionRate(lua_State* tolua_S)
14164 {
14165 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14166 #ifndef TOLUA_RELEASE
14167 tolua_Error tolua_err;
14168 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaProductionRate'",NULL);
14169 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14170 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14171 #endif
14172 self->SetMagmaProductionRate(((int) tolua_tonumber(tolua_S,2,0))
14173 )
14174 ;
14175 return 0;
14176 }
14177 #endif //#ifndef TOLUA_DISABLE
14178
14179 /* get function: EnergyStored of class CPlayer */
14180 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_EnergyStored
14181 static int tolua_get_CPlayer_EnergyStored(lua_State* tolua_S)
14182 {
14183 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14184 #ifndef TOLUA_RELEASE
14185 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyStored'",NULL);
14186 #endif
14187 tolua_pushnumber(tolua_S,(lua_Number)self->GetEnergyStored());
14188 return 1;
14189 }
14190 #endif //#ifndef TOLUA_DISABLE
14191
14192 /* set function: EnergyStored of class CPlayer */
14193 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_EnergyStored
14194 static int tolua_set_CPlayer_EnergyStored(lua_State* tolua_S)
14195 {
14196 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14197 #ifndef TOLUA_RELEASE
14198 tolua_Error tolua_err;
14199 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyStored'",NULL);
14200 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14201 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14202 #endif
14203 self->SetEnergyStored(((int) tolua_tonumber(tolua_S,2,0))
14204 )
14205 ;
14206 return 0;
14207 }
14208 #endif //#ifndef TOLUA_DISABLE
14209
14210 /* get function: MagmaStored of class CPlayer */
14211 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_MagmaStored
14212 static int tolua_get_CPlayer_MagmaStored(lua_State* tolua_S)
14213 {
14214 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14215 #ifndef TOLUA_RELEASE
14216 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaStored'",NULL);
14217 #endif
14218 tolua_pushnumber(tolua_S,(lua_Number)self->GetMagmaStored());
14219 return 1;
14220 }
14221 #endif //#ifndef TOLUA_DISABLE
14222
14223 /* set function: MagmaStored of class CPlayer */
14224 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_MagmaStored
14225 static int tolua_set_CPlayer_MagmaStored(lua_State* tolua_S)
14226 {
14227 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14228 #ifndef TOLUA_RELEASE
14229 tolua_Error tolua_err;
14230 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaStored'",NULL);
14231 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14232 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14233 #endif
14234 self->SetMagmaStored(((int) tolua_tonumber(tolua_S,2,0))
14235 )
14236 ;
14237 return 0;
14238 }
14239 #endif //#ifndef TOLUA_DISABLE
14240
14241 /* get function: EnergyStorageCapacity of class CPlayer */
14242 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_EnergyStorageCapacity
14243 static int tolua_get_CPlayer_EnergyStorageCapacity(lua_State* tolua_S)
14244 {
14245 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14246 #ifndef TOLUA_RELEASE
14247 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyStorageCapacity'",NULL);
14248 #endif
14249 tolua_pushnumber(tolua_S,(lua_Number)self->GetEnergyStorageCapacity());
14250 return 1;
14251 }
14252 #endif //#ifndef TOLUA_DISABLE
14253
14254 /* set function: EnergyStorageCapacity of class CPlayer */
14255 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_EnergyStorageCapacity
14256 static int tolua_set_CPlayer_EnergyStorageCapacity(lua_State* tolua_S)
14257 {
14258 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14259 #ifndef TOLUA_RELEASE
14260 tolua_Error tolua_err;
14261 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyStorageCapacity'",NULL);
14262 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14263 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14264 #endif
14265 self->SetEnergyStorageCapacity(((int) tolua_tonumber(tolua_S,2,0))
14266 )
14267 ;
14268 return 0;
14269 }
14270 #endif //#ifndef TOLUA_DISABLE
14271
14272 /* get function: MagmaStorageCapacity of class CPlayer */
14273 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_MagmaStorageCapacity
14274 static int tolua_get_CPlayer_MagmaStorageCapacity(lua_State* tolua_S)
14275 {
14276 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14277 #ifndef TOLUA_RELEASE
14278 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaStorageCapacity'",NULL);
14279 #endif
14280 tolua_pushnumber(tolua_S,(lua_Number)self->GetMagmaStorageCapacity());
14281 return 1;
14282 }
14283 #endif //#ifndef TOLUA_DISABLE
14284
14285 /* set function: MagmaStorageCapacity of class CPlayer */
14286 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_MagmaStorageCapacity
14287 static int tolua_set_CPlayer_MagmaStorageCapacity(lua_State* tolua_S)
14288 {
14289 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14290 #ifndef TOLUA_RELEASE
14291 tolua_Error tolua_err;
14292 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaStorageCapacity'",NULL);
14293 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14294 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14295 #endif
14296 self->SetMagmaStorageCapacity(((int) tolua_tonumber(tolua_S,2,0))
14297 )
14298 ;
14299 return 0;
14300 }
14301 #endif //#ifndef TOLUA_DISABLE
14302
14303 /* get function: UnitTypesCount of class CPlayer */
14304 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CPlayer_UnitTypesCount
14305 static int tolua_get_stratagus_CPlayer_UnitTypesCount(lua_State* tolua_S)
14306 {
14307 int tolua_index;
14308 CPlayer* self;
14309 lua_pushstring(tolua_S,".self");
14310 lua_rawget(tolua_S,1);
14311 self = (CPlayer*) lua_touserdata(tolua_S,-1);
14312 #ifndef TOLUA_RELEASE
14313 {
14314 tolua_Error tolua_err;
14315 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14316 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
14317 }
14318 #endif
14319 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
14320 #ifndef TOLUA_RELEASE
14321 if (tolua_index<0 || tolua_index>=UnitTypeMax)
14322 tolua_error(tolua_S,"array indexing out of range.",NULL);
14323 #endif
14324 tolua_pushnumber(tolua_S,(lua_Number)self->UnitTypesCount[tolua_index]);
14325 return 1;
14326 }
14327 #endif //#ifndef TOLUA_DISABLE
14328
14329 /* get function: AiEnabled of class CPlayer */
14330 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_AiEnabled
14331 static int tolua_get_CPlayer_AiEnabled(lua_State* tolua_S)
14332 {
14333 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14334 #ifndef TOLUA_RELEASE
14335 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AiEnabled'",NULL);
14336 #endif
14337 tolua_pushnumber(tolua_S,(lua_Number)self->AiEnabled);
14338 return 1;
14339 }
14340 #endif //#ifndef TOLUA_DISABLE
14341
14342 /* set function: AiEnabled of class CPlayer */
14343 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_AiEnabled
14344 static int tolua_set_CPlayer_AiEnabled(lua_State* tolua_S)
14345 {
14346 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14347 #ifndef TOLUA_RELEASE
14348 tolua_Error tolua_err;
14349 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AiEnabled'",NULL);
14350 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14351 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14352 #endif
14353 self->AiEnabled = ((int) tolua_tonumber(tolua_S,2,0))
14354 ;
14355 return 0;
14356 }
14357 #endif //#ifndef TOLUA_DISABLE
14358
14359 /* get function: Units of class CPlayer */
14360 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CPlayer_Units
14361 static int tolua_get_stratagus_CPlayer_Units(lua_State* tolua_S)
14362 {
14363 int tolua_index;
14364 CPlayer* self;
14365 lua_pushstring(tolua_S,".self");
14366 lua_rawget(tolua_S,1);
14367 self = (CPlayer*) lua_touserdata(tolua_S,-1);
14368 #ifndef TOLUA_RELEASE
14369 {
14370 tolua_Error tolua_err;
14371 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14372 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
14373 }
14374 #endif
14375 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
14376 #ifndef TOLUA_RELEASE
14377 if (tolua_index<0 || tolua_index>=UnitMax)
14378 tolua_error(tolua_S,"array indexing out of range.",NULL);
14379 #endif
14380 tolua_pushusertype(tolua_S,(void*)self->Units[tolua_index],"CUnit");
14381 return 1;
14382 }
14383 #endif //#ifndef TOLUA_DISABLE
14384
14385 /* set function: Units of class CPlayer */
14386 #ifndef TOLUA_DISABLE_tolua_set_stratagus_CPlayer_Units
14387 static int tolua_set_stratagus_CPlayer_Units(lua_State* tolua_S)
14388 {
14389 int tolua_index;
14390 CPlayer* self;
14391 lua_pushstring(tolua_S,".self");
14392 lua_rawget(tolua_S,1);
14393 self = (CPlayer*) lua_touserdata(tolua_S,-1);
14394 #ifndef TOLUA_RELEASE
14395 {
14396 tolua_Error tolua_err;
14397 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14398 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
14399 }
14400 #endif
14401 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
14402 #ifndef TOLUA_RELEASE
14403 if (tolua_index<0 || tolua_index>=UnitMax)
14404 tolua_error(tolua_S,"array indexing out of range.",NULL);
14405 #endif
14406 self->Units[tolua_index] = ((CUnit*) tolua_tousertype(tolua_S,3,0));
14407 return 0;
14408 }
14409 #endif //#ifndef TOLUA_DISABLE
14410
14411 /* get function: TotalNumUnits of class CPlayer */
14412 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_TotalNumUnits
14413 static int tolua_get_CPlayer_TotalNumUnits(lua_State* tolua_S)
14414 {
14415 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14416 #ifndef TOLUA_RELEASE
14417 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalNumUnits'",NULL);
14418 #endif
14419 tolua_pushnumber(tolua_S,(lua_Number)self->TotalNumUnits);
14420 return 1;
14421 }
14422 #endif //#ifndef TOLUA_DISABLE
14423
14424 /* set function: TotalNumUnits of class CPlayer */
14425 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_TotalNumUnits
14426 static int tolua_set_CPlayer_TotalNumUnits(lua_State* tolua_S)
14427 {
14428 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14429 #ifndef TOLUA_RELEASE
14430 tolua_Error tolua_err;
14431 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalNumUnits'",NULL);
14432 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14433 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14434 #endif
14435 self->TotalNumUnits = ((int) tolua_tonumber(tolua_S,2,0))
14436 ;
14437 return 0;
14438 }
14439 #endif //#ifndef TOLUA_DISABLE
14440
14441 /* get function: NumBuildings of class CPlayer */
14442 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_NumBuildings
14443 static int tolua_get_CPlayer_NumBuildings(lua_State* tolua_S)
14444 {
14445 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14446 #ifndef TOLUA_RELEASE
14447 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NumBuildings'",NULL);
14448 #endif
14449 tolua_pushnumber(tolua_S,(lua_Number)self->NumBuildings);
14450 return 1;
14451 }
14452 #endif //#ifndef TOLUA_DISABLE
14453
14454 /* set function: NumBuildings of class CPlayer */
14455 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_NumBuildings
14456 static int tolua_set_CPlayer_NumBuildings(lua_State* tolua_S)
14457 {
14458 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14459 #ifndef TOLUA_RELEASE
14460 tolua_Error tolua_err;
14461 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NumBuildings'",NULL);
14462 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14463 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14464 #endif
14465 self->NumBuildings = ((int) tolua_tonumber(tolua_S,2,0))
14466 ;
14467 return 0;
14468 }
14469 #endif //#ifndef TOLUA_DISABLE
14470
14471 /* get function: UnitLimit of class CPlayer */
14472 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_UnitLimit
14473 static int tolua_get_CPlayer_UnitLimit(lua_State* tolua_S)
14474 {
14475 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14476 #ifndef TOLUA_RELEASE
14477 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UnitLimit'",NULL);
14478 #endif
14479 tolua_pushnumber(tolua_S,(lua_Number)self->UnitLimit);
14480 return 1;
14481 }
14482 #endif //#ifndef TOLUA_DISABLE
14483
14484 /* set function: UnitLimit of class CPlayer */
14485 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_UnitLimit
14486 static int tolua_set_CPlayer_UnitLimit(lua_State* tolua_S)
14487 {
14488 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14489 #ifndef TOLUA_RELEASE
14490 tolua_Error tolua_err;
14491 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UnitLimit'",NULL);
14492 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14493 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14494 #endif
14495 self->UnitLimit = ((int) tolua_tonumber(tolua_S,2,0))
14496 ;
14497 return 0;
14498 }
14499 #endif //#ifndef TOLUA_DISABLE
14500
14501 /* get function: BuildingLimit of class CPlayer */
14502 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_BuildingLimit
14503 static int tolua_get_CPlayer_BuildingLimit(lua_State* tolua_S)
14504 {
14505 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14506 #ifndef TOLUA_RELEASE
14507 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BuildingLimit'",NULL);
14508 #endif
14509 tolua_pushnumber(tolua_S,(lua_Number)self->BuildingLimit);
14510 return 1;
14511 }
14512 #endif //#ifndef TOLUA_DISABLE
14513
14514 /* set function: BuildingLimit of class CPlayer */
14515 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_BuildingLimit
14516 static int tolua_set_CPlayer_BuildingLimit(lua_State* tolua_S)
14517 {
14518 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14519 #ifndef TOLUA_RELEASE
14520 tolua_Error tolua_err;
14521 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BuildingLimit'",NULL);
14522 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14523 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14524 #endif
14525 self->BuildingLimit = ((int) tolua_tonumber(tolua_S,2,0))
14526 ;
14527 return 0;
14528 }
14529 #endif //#ifndef TOLUA_DISABLE
14530
14531 /* get function: TotalUnitLimit of class CPlayer */
14532 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_TotalUnitLimit
14533 static int tolua_get_CPlayer_TotalUnitLimit(lua_State* tolua_S)
14534 {
14535 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14536 #ifndef TOLUA_RELEASE
14537 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalUnitLimit'",NULL);
14538 #endif
14539 tolua_pushnumber(tolua_S,(lua_Number)self->TotalUnitLimit);
14540 return 1;
14541 }
14542 #endif //#ifndef TOLUA_DISABLE
14543
14544 /* set function: TotalUnitLimit of class CPlayer */
14545 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_TotalUnitLimit
14546 static int tolua_set_CPlayer_TotalUnitLimit(lua_State* tolua_S)
14547 {
14548 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14549 #ifndef TOLUA_RELEASE
14550 tolua_Error tolua_err;
14551 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalUnitLimit'",NULL);
14552 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14553 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14554 #endif
14555 self->TotalUnitLimit = ((int) tolua_tonumber(tolua_S,2,0))
14556 ;
14557 return 0;
14558 }
14559 #endif //#ifndef TOLUA_DISABLE
14560
14561 /* get function: Score of class CPlayer */
14562 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_Score
14563 static int tolua_get_CPlayer_Score(lua_State* tolua_S)
14564 {
14565 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14566 #ifndef TOLUA_RELEASE
14567 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Score'",NULL);
14568 #endif
14569 tolua_pushnumber(tolua_S,(lua_Number)self->Score);
14570 return 1;
14571 }
14572 #endif //#ifndef TOLUA_DISABLE
14573
14574 /* set function: Score of class CPlayer */
14575 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_Score
14576 static int tolua_set_CPlayer_Score(lua_State* tolua_S)
14577 {
14578 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14579 #ifndef TOLUA_RELEASE
14580 tolua_Error tolua_err;
14581 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Score'",NULL);
14582 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14583 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14584 #endif
14585 self->Score = ((int) tolua_tonumber(tolua_S,2,0))
14586 ;
14587 return 0;
14588 }
14589 #endif //#ifndef TOLUA_DISABLE
14590
14591 /* get function: TotalUnits of class CPlayer */
14592 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_TotalUnits
14593 static int tolua_get_CPlayer_TotalUnits(lua_State* tolua_S)
14594 {
14595 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14596 #ifndef TOLUA_RELEASE
14597 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalUnits'",NULL);
14598 #endif
14599 tolua_pushnumber(tolua_S,(lua_Number)self->TotalUnits);
14600 return 1;
14601 }
14602 #endif //#ifndef TOLUA_DISABLE
14603
14604 /* set function: TotalUnits of class CPlayer */
14605 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_TotalUnits
14606 static int tolua_set_CPlayer_TotalUnits(lua_State* tolua_S)
14607 {
14608 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14609 #ifndef TOLUA_RELEASE
14610 tolua_Error tolua_err;
14611 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalUnits'",NULL);
14612 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14613 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14614 #endif
14615 self->TotalUnits = ((int) tolua_tonumber(tolua_S,2,0))
14616 ;
14617 return 0;
14618 }
14619 #endif //#ifndef TOLUA_DISABLE
14620
14621 /* get function: TotalBuildings of class CPlayer */
14622 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_TotalBuildings
14623 static int tolua_get_CPlayer_TotalBuildings(lua_State* tolua_S)
14624 {
14625 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14626 #ifndef TOLUA_RELEASE
14627 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalBuildings'",NULL);
14628 #endif
14629 tolua_pushnumber(tolua_S,(lua_Number)self->TotalBuildings);
14630 return 1;
14631 }
14632 #endif //#ifndef TOLUA_DISABLE
14633
14634 /* set function: TotalBuildings of class CPlayer */
14635 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_TotalBuildings
14636 static int tolua_set_CPlayer_TotalBuildings(lua_State* tolua_S)
14637 {
14638 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14639 #ifndef TOLUA_RELEASE
14640 tolua_Error tolua_err;
14641 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalBuildings'",NULL);
14642 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14643 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14644 #endif
14645 self->TotalBuildings = ((int) tolua_tonumber(tolua_S,2,0))
14646 ;
14647 return 0;
14648 }
14649 #endif //#ifndef TOLUA_DISABLE
14650
14651 /* get function: TotalEnergy of class CPlayer */
14652 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_TotalEnergy
14653 static int tolua_get_CPlayer_TotalEnergy(lua_State* tolua_S)
14654 {
14655 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14656 #ifndef TOLUA_RELEASE
14657 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalEnergy'",NULL);
14658 #endif
14659 tolua_pushnumber(tolua_S,(lua_Number)self->GetTotalEnergy());
14660 return 1;
14661 }
14662 #endif //#ifndef TOLUA_DISABLE
14663
14664 /* set function: TotalEnergy of class CPlayer */
14665 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_TotalEnergy
14666 static int tolua_set_CPlayer_TotalEnergy(lua_State* tolua_S)
14667 {
14668 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14669 #ifndef TOLUA_RELEASE
14670 tolua_Error tolua_err;
14671 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalEnergy'",NULL);
14672 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14673 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14674 #endif
14675 self->SetTotalEnergy(((int) tolua_tonumber(tolua_S,2,0))
14676 )
14677 ;
14678 return 0;
14679 }
14680 #endif //#ifndef TOLUA_DISABLE
14681
14682 /* get function: TotalMagma of class CPlayer */
14683 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_TotalMagma
14684 static int tolua_get_CPlayer_TotalMagma(lua_State* tolua_S)
14685 {
14686 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14687 #ifndef TOLUA_RELEASE
14688 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalMagma'",NULL);
14689 #endif
14690 tolua_pushnumber(tolua_S,(lua_Number)self->GetTotalMagma());
14691 return 1;
14692 }
14693 #endif //#ifndef TOLUA_DISABLE
14694
14695 /* set function: TotalMagma of class CPlayer */
14696 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_TotalMagma
14697 static int tolua_set_CPlayer_TotalMagma(lua_State* tolua_S)
14698 {
14699 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14700 #ifndef TOLUA_RELEASE
14701 tolua_Error tolua_err;
14702 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalMagma'",NULL);
14703 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14704 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14705 #endif
14706 self->SetTotalMagma(((int) tolua_tonumber(tolua_S,2,0))
14707 )
14708 ;
14709 return 0;
14710 }
14711 #endif //#ifndef TOLUA_DISABLE
14712
14713 /* get function: TotalRazings of class CPlayer */
14714 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_TotalRazings
14715 static int tolua_get_CPlayer_TotalRazings(lua_State* tolua_S)
14716 {
14717 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14718 #ifndef TOLUA_RELEASE
14719 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalRazings'",NULL);
14720 #endif
14721 tolua_pushnumber(tolua_S,(lua_Number)self->TotalRazings);
14722 return 1;
14723 }
14724 #endif //#ifndef TOLUA_DISABLE
14725
14726 /* set function: TotalRazings of class CPlayer */
14727 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_TotalRazings
14728 static int tolua_set_CPlayer_TotalRazings(lua_State* tolua_S)
14729 {
14730 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14731 #ifndef TOLUA_RELEASE
14732 tolua_Error tolua_err;
14733 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalRazings'",NULL);
14734 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14735 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14736 #endif
14737 self->TotalRazings = ((int) tolua_tonumber(tolua_S,2,0))
14738 ;
14739 return 0;
14740 }
14741 #endif //#ifndef TOLUA_DISABLE
14742
14743 /* get function: TotalKills of class CPlayer */
14744 #ifndef TOLUA_DISABLE_tolua_get_CPlayer_TotalKills
14745 static int tolua_get_CPlayer_TotalKills(lua_State* tolua_S)
14746 {
14747 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14748 #ifndef TOLUA_RELEASE
14749 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalKills'",NULL);
14750 #endif
14751 tolua_pushnumber(tolua_S,(lua_Number)self->TotalKills);
14752 return 1;
14753 }
14754 #endif //#ifndef TOLUA_DISABLE
14755
14756 /* set function: TotalKills of class CPlayer */
14757 #ifndef TOLUA_DISABLE_tolua_set_CPlayer_TotalKills
14758 static int tolua_set_CPlayer_TotalKills(lua_State* tolua_S)
14759 {
14760 CPlayer* self = (CPlayer*) tolua_tousertype(tolua_S,1,0);
14761 #ifndef TOLUA_RELEASE
14762 tolua_Error tolua_err;
14763 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TotalKills'",NULL);
14764 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
14765 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
14766 #endif
14767 self->TotalKills = ((int) tolua_tonumber(tolua_S,2,0))
14768 ;
14769 return 0;
14770 }
14771 #endif //#ifndef TOLUA_DISABLE
14772
14773 /* method: IsEnemy of class CPlayer */
14774 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsEnemy00
14775 static int tolua_stratagus_CPlayer_IsEnemy00(lua_State* tolua_S)
14776 {
14777 #ifndef TOLUA_RELEASE
14778 tolua_Error tolua_err;
14779 if (
14780 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
14781 !tolua_isusertype(tolua_S,2,"const CPlayer",0,&tolua_err) ||
14782 !tolua_isnoobj(tolua_S,3,&tolua_err)
14783 )
14784 goto tolua_lerror;
14785 else
14786 #endif
14787 {
14788 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
14789 const CPlayer* x = ((const CPlayer*) tolua_tousertype(tolua_S,2,0));
14790 #ifndef TOLUA_RELEASE
14791 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsEnemy'", NULL);
14792 #endif
14793 {
14794 bool tolua_ret = (bool) self->IsEnemy(x);
14795 tolua_pushboolean(tolua_S,(bool)tolua_ret);
14796 }
14797 }
14798 return 1;
14799 #ifndef TOLUA_RELEASE
14800 tolua_lerror:
14801 tolua_error(tolua_S,"#ferror in function 'IsEnemy'.",&tolua_err);
14802 return 0;
14803 #endif
14804 }
14805 #endif //#ifndef TOLUA_DISABLE
14806
14807 /* method: IsEnemy of class CPlayer */
14808 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsEnemy01
14809 static int tolua_stratagus_CPlayer_IsEnemy01(lua_State* tolua_S)
14810 {
14811 tolua_Error tolua_err;
14812 if (
14813 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
14814 !tolua_isusertype(tolua_S,2,"const CUnit",0,&tolua_err) ||
14815 !tolua_isnoobj(tolua_S,3,&tolua_err)
14816 )
14817 goto tolua_lerror;
14818 else
14819 {
14820 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
14821 const CUnit* x = ((const CUnit*) tolua_tousertype(tolua_S,2,0));
14822 #ifndef TOLUA_RELEASE
14823 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsEnemy'", NULL);
14824 #endif
14825 {
14826 bool tolua_ret = (bool) self->IsEnemy(x);
14827 tolua_pushboolean(tolua_S,(bool)tolua_ret);
14828 }
14829 }
14830 return 1;
14831 tolua_lerror:
14832 return tolua_stratagus_CPlayer_IsEnemy00(tolua_S);
14833 }
14834 #endif //#ifndef TOLUA_DISABLE
14835
14836 /* method: IsAllied of class CPlayer */
14837 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsAllied00
14838 static int tolua_stratagus_CPlayer_IsAllied00(lua_State* tolua_S)
14839 {
14840 #ifndef TOLUA_RELEASE
14841 tolua_Error tolua_err;
14842 if (
14843 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
14844 !tolua_isusertype(tolua_S,2,"const CPlayer",0,&tolua_err) ||
14845 !tolua_isnoobj(tolua_S,3,&tolua_err)
14846 )
14847 goto tolua_lerror;
14848 else
14849 #endif
14850 {
14851 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
14852 const CPlayer* x = ((const CPlayer*) tolua_tousertype(tolua_S,2,0));
14853 #ifndef TOLUA_RELEASE
14854 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsAllied'", NULL);
14855 #endif
14856 {
14857 bool tolua_ret = (bool) self->IsAllied(x);
14858 tolua_pushboolean(tolua_S,(bool)tolua_ret);
14859 }
14860 }
14861 return 1;
14862 #ifndef TOLUA_RELEASE
14863 tolua_lerror:
14864 tolua_error(tolua_S,"#ferror in function 'IsAllied'.",&tolua_err);
14865 return 0;
14866 #endif
14867 }
14868 #endif //#ifndef TOLUA_DISABLE
14869
14870 /* method: IsAllied of class CPlayer */
14871 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsAllied01
14872 static int tolua_stratagus_CPlayer_IsAllied01(lua_State* tolua_S)
14873 {
14874 tolua_Error tolua_err;
14875 if (
14876 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
14877 !tolua_isusertype(tolua_S,2,"const CUnit",0,&tolua_err) ||
14878 !tolua_isnoobj(tolua_S,3,&tolua_err)
14879 )
14880 goto tolua_lerror;
14881 else
14882 {
14883 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
14884 const CUnit* x = ((const CUnit*) tolua_tousertype(tolua_S,2,0));
14885 #ifndef TOLUA_RELEASE
14886 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsAllied'", NULL);
14887 #endif
14888 {
14889 bool tolua_ret = (bool) self->IsAllied(x);
14890 tolua_pushboolean(tolua_S,(bool)tolua_ret);
14891 }
14892 }
14893 return 1;
14894 tolua_lerror:
14895 return tolua_stratagus_CPlayer_IsAllied00(tolua_S);
14896 }
14897 #endif //#ifndef TOLUA_DISABLE
14898
14899 /* method: IsSharedVision of class CPlayer */
14900 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsSharedVision00
14901 static int tolua_stratagus_CPlayer_IsSharedVision00(lua_State* tolua_S)
14902 {
14903 #ifndef TOLUA_RELEASE
14904 tolua_Error tolua_err;
14905 if (
14906 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
14907 !tolua_isusertype(tolua_S,2,"const CPlayer",0,&tolua_err) ||
14908 !tolua_isnoobj(tolua_S,3,&tolua_err)
14909 )
14910 goto tolua_lerror;
14911 else
14912 #endif
14913 {
14914 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
14915 const CPlayer* x = ((const CPlayer*) tolua_tousertype(tolua_S,2,0));
14916 #ifndef TOLUA_RELEASE
14917 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSharedVision'", NULL);
14918 #endif
14919 {
14920 bool tolua_ret = (bool) self->IsSharedVision(x);
14921 tolua_pushboolean(tolua_S,(bool)tolua_ret);
14922 }
14923 }
14924 return 1;
14925 #ifndef TOLUA_RELEASE
14926 tolua_lerror:
14927 tolua_error(tolua_S,"#ferror in function 'IsSharedVision'.",&tolua_err);
14928 return 0;
14929 #endif
14930 }
14931 #endif //#ifndef TOLUA_DISABLE
14932
14933 /* method: IsSharedVision of class CPlayer */
14934 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsSharedVision01
14935 static int tolua_stratagus_CPlayer_IsSharedVision01(lua_State* tolua_S)
14936 {
14937 tolua_Error tolua_err;
14938 if (
14939 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
14940 !tolua_isusertype(tolua_S,2,"const CUnit",0,&tolua_err) ||
14941 !tolua_isnoobj(tolua_S,3,&tolua_err)
14942 )
14943 goto tolua_lerror;
14944 else
14945 {
14946 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
14947 const CUnit* x = ((const CUnit*) tolua_tousertype(tolua_S,2,0));
14948 #ifndef TOLUA_RELEASE
14949 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSharedVision'", NULL);
14950 #endif
14951 {
14952 bool tolua_ret = (bool) self->IsSharedVision(x);
14953 tolua_pushboolean(tolua_S,(bool)tolua_ret);
14954 }
14955 }
14956 return 1;
14957 tolua_lerror:
14958 return tolua_stratagus_CPlayer_IsSharedVision00(tolua_S);
14959 }
14960 #endif //#ifndef TOLUA_DISABLE
14961
14962 /* method: IsBothSharedVision of class CPlayer */
14963 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsBothSharedVision00
14964 static int tolua_stratagus_CPlayer_IsBothSharedVision00(lua_State* tolua_S)
14965 {
14966 #ifndef TOLUA_RELEASE
14967 tolua_Error tolua_err;
14968 if (
14969 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
14970 !tolua_isusertype(tolua_S,2,"const CPlayer",0,&tolua_err) ||
14971 !tolua_isnoobj(tolua_S,3,&tolua_err)
14972 )
14973 goto tolua_lerror;
14974 else
14975 #endif
14976 {
14977 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
14978 const CPlayer* x = ((const CPlayer*) tolua_tousertype(tolua_S,2,0));
14979 #ifndef TOLUA_RELEASE
14980 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsBothSharedVision'", NULL);
14981 #endif
14982 {
14983 bool tolua_ret = (bool) self->IsBothSharedVision(x);
14984 tolua_pushboolean(tolua_S,(bool)tolua_ret);
14985 }
14986 }
14987 return 1;
14988 #ifndef TOLUA_RELEASE
14989 tolua_lerror:
14990 tolua_error(tolua_S,"#ferror in function 'IsBothSharedVision'.",&tolua_err);
14991 return 0;
14992 #endif
14993 }
14994 #endif //#ifndef TOLUA_DISABLE
14995
14996 /* method: IsBothSharedVision of class CPlayer */
14997 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsBothSharedVision01
14998 static int tolua_stratagus_CPlayer_IsBothSharedVision01(lua_State* tolua_S)
14999 {
15000 tolua_Error tolua_err;
15001 if (
15002 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
15003 !tolua_isusertype(tolua_S,2,"const CUnit",0,&tolua_err) ||
15004 !tolua_isnoobj(tolua_S,3,&tolua_err)
15005 )
15006 goto tolua_lerror;
15007 else
15008 {
15009 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
15010 const CUnit* x = ((const CUnit*) tolua_tousertype(tolua_S,2,0));
15011 #ifndef TOLUA_RELEASE
15012 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsBothSharedVision'", NULL);
15013 #endif
15014 {
15015 bool tolua_ret = (bool) self->IsBothSharedVision(x);
15016 tolua_pushboolean(tolua_S,(bool)tolua_ret);
15017 }
15018 }
15019 return 1;
15020 tolua_lerror:
15021 return tolua_stratagus_CPlayer_IsBothSharedVision00(tolua_S);
15022 }
15023 #endif //#ifndef TOLUA_DISABLE
15024
15025 /* method: IsTeamed of class CPlayer */
15026 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsTeamed00
15027 static int tolua_stratagus_CPlayer_IsTeamed00(lua_State* tolua_S)
15028 {
15029 #ifndef TOLUA_RELEASE
15030 tolua_Error tolua_err;
15031 if (
15032 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
15033 !tolua_isusertype(tolua_S,2,"const CPlayer",0,&tolua_err) ||
15034 !tolua_isnoobj(tolua_S,3,&tolua_err)
15035 )
15036 goto tolua_lerror;
15037 else
15038 #endif
15039 {
15040 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
15041 const CPlayer* x = ((const CPlayer*) tolua_tousertype(tolua_S,2,0));
15042 #ifndef TOLUA_RELEASE
15043 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsTeamed'", NULL);
15044 #endif
15045 {
15046 bool tolua_ret = (bool) self->IsTeamed(x);
15047 tolua_pushboolean(tolua_S,(bool)tolua_ret);
15048 }
15049 }
15050 return 1;
15051 #ifndef TOLUA_RELEASE
15052 tolua_lerror:
15053 tolua_error(tolua_S,"#ferror in function 'IsTeamed'.",&tolua_err);
15054 return 0;
15055 #endif
15056 }
15057 #endif //#ifndef TOLUA_DISABLE
15058
15059 /* method: IsTeamed of class CPlayer */
15060 #ifndef TOLUA_DISABLE_tolua_stratagus_CPlayer_IsTeamed01
15061 static int tolua_stratagus_CPlayer_IsTeamed01(lua_State* tolua_S)
15062 {
15063 tolua_Error tolua_err;
15064 if (
15065 !tolua_isusertype(tolua_S,1,"const CPlayer",0,&tolua_err) ||
15066 !tolua_isusertype(tolua_S,2,"const CUnit",0,&tolua_err) ||
15067 !tolua_isnoobj(tolua_S,3,&tolua_err)
15068 )
15069 goto tolua_lerror;
15070 else
15071 {
15072 const CPlayer* self = (const CPlayer*) tolua_tousertype(tolua_S,1,0);
15073 const CUnit* x = ((const CUnit*) tolua_tousertype(tolua_S,2,0));
15074 #ifndef TOLUA_RELEASE
15075 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsTeamed'", NULL);
15076 #endif
15077 {
15078 bool tolua_ret = (bool) self->IsTeamed(x);
15079 tolua_pushboolean(tolua_S,(bool)tolua_ret);
15080 }
15081 }
15082 return 1;
15083 tolua_lerror:
15084 return tolua_stratagus_CPlayer_IsTeamed00(tolua_S);
15085 }
15086 #endif //#ifndef TOLUA_DISABLE
15087
15088 /* get function: Players */
15089 #ifndef TOLUA_DISABLE_tolua_get_stratagus_Players
15090 static int tolua_get_stratagus_Players(lua_State* tolua_S)
15091 {
15092 int tolua_index;
15093 #ifndef TOLUA_RELEASE
15094 {
15095 tolua_Error tolua_err;
15096 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15097 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
15098 }
15099 #endif
15100 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
15101 #ifndef TOLUA_RELEASE
15102 if (tolua_index<0 || tolua_index>=PlayerMax)
15103 tolua_error(tolua_S,"array indexing out of range.",NULL);
15104 #endif
15105 tolua_pushusertype(tolua_S,(void*)&Players[tolua_index],"CPlayer");
15106 return 1;
15107 }
15108 #endif //#ifndef TOLUA_DISABLE
15109
15110 /* set function: Players */
15111 #ifndef TOLUA_DISABLE_tolua_set_stratagus_Players
15112 static int tolua_set_stratagus_Players(lua_State* tolua_S)
15113 {
15114 int tolua_index;
15115 #ifndef TOLUA_RELEASE
15116 {
15117 tolua_Error tolua_err;
15118 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15119 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
15120 }
15121 #endif
15122 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
15123 #ifndef TOLUA_RELEASE
15124 if (tolua_index<0 || tolua_index>=PlayerMax)
15125 tolua_error(tolua_S,"array indexing out of range.",NULL);
15126 #endif
15127 Players[tolua_index] = *((CPlayer*) tolua_tousertype(tolua_S,3,0));
15128 return 0;
15129 }
15130 #endif //#ifndef TOLUA_DISABLE
15131
15132 /* get function: ThisPlayer */
15133 #ifndef TOLUA_DISABLE_tolua_get_ThisPlayer_ptr
15134 static int tolua_get_ThisPlayer_ptr(lua_State* tolua_S)
15135 {
15136 tolua_pushusertype(tolua_S,(void*)ThisPlayer,"CPlayer");
15137 return 1;
15138 }
15139 #endif //#ifndef TOLUA_DISABLE
15140
15141 /* set function: ThisPlayer */
15142 #ifndef TOLUA_DISABLE_tolua_set_ThisPlayer_ptr
15143 static int tolua_set_ThisPlayer_ptr(lua_State* tolua_S)
15144 {
15145 #ifndef TOLUA_RELEASE
15146 tolua_Error tolua_err;
15147 if (!tolua_isusertype(tolua_S,2,"CPlayer",0,&tolua_err))
15148 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15149 #endif
15150 ThisPlayer = ((CPlayer*) tolua_tousertype(tolua_S,2,0))
15151 ;
15152 return 0;
15153 }
15154 #endif //#ifndef TOLUA_DISABLE
15155
15156 /* function: CclChangeUnitsOwner */
15157 #ifndef TOLUA_DISABLE_tolua_stratagus_ChangeUnitsOwner00
15158 static int tolua_stratagus_ChangeUnitsOwner00(lua_State* tolua_S)
15159 {
15160 #ifndef TOLUA_RELEASE
15161 tolua_Error tolua_err;
15162 if (
15163 !tolua_istable(tolua_S,1,0,&tolua_err) ||
15164 !tolua_istable(tolua_S,2,0,&tolua_err) ||
15165 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
15166 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
15167 !tolua_isnoobj(tolua_S,6,&tolua_err)
15168 )
15169 goto tolua_lerror;
15170 else
15171 #endif
15172 {
15173 int topLeft[2];
15174 int bottomRight[2];
15175 int oldPlayer = ((int) tolua_tonumber(tolua_S,3,0));
15176 int newPlayer = ((int) tolua_tonumber(tolua_S,4,0));
15177 lua_Object unitType = ((lua_Object) tolua_tovalue(tolua_S,5,0));
15178 lua_State* l = tolua_S;
15179 {
15180 #ifndef TOLUA_RELEASE
15181 if (!tolua_isnumberarray(tolua_S,1,2,0,&tolua_err))
15182 goto tolua_lerror;
15183 else
15184 #endif
15185 {
15186 int i;
15187 for(i=0; i<2;i++)
15188 topLeft[i] = ((int) tolua_tofieldnumber(tolua_S,1,i+1,0));
15189 }
15190 }
15191 {
15192 #ifndef TOLUA_RELEASE
15193 if (!tolua_isnumberarray(tolua_S,2,2,0,&tolua_err))
15194 goto tolua_lerror;
15195 else
15196 #endif
15197 {
15198 int i;
15199 for(i=0; i<2;i++)
15200 bottomRight[i] = ((int) tolua_tofieldnumber(tolua_S,2,i+1,0));
15201 }
15202 }
15203 {
15204 CclChangeUnitsOwner(topLeft,bottomRight,oldPlayer,newPlayer,unitType,l);
15205 }
15206 {
15207 int i;
15208 for(i=0; i<2;i++)
15209 tolua_pushfieldnumber(tolua_S,1,i+1,(lua_Number) topLeft[i]);
15210 }
15211 {
15212 int i;
15213 for(i=0; i<2;i++)
15214 tolua_pushfieldnumber(tolua_S,2,i+1,(lua_Number) bottomRight[i]);
15215 }
15216 }
15217 return 0;
15218 #ifndef TOLUA_RELEASE
15219 tolua_lerror:
15220 tolua_error(tolua_S,"#ferror in function 'ChangeUnitsOwner'.",&tolua_err);
15221 return 0;
15222 #endif
15223 }
15224 #endif //#ifndef TOLUA_DISABLE
15225
15226 /* get function: Ident of class CUnitType */
15227 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_Ident
15228 static int tolua_get_CUnitType_Ident(lua_State* tolua_S)
15229 {
15230 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15231 #ifndef TOLUA_RELEASE
15232 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Ident'",NULL);
15233 #endif
15234 tolua_pushcppstring(tolua_S,(const char*)self->Ident);
15235 return 1;
15236 }
15237 #endif //#ifndef TOLUA_DISABLE
15238
15239 /* set function: Ident of class CUnitType */
15240 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_Ident
15241 static int tolua_set_CUnitType_Ident(lua_State* tolua_S)
15242 {
15243 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15244 #ifndef TOLUA_RELEASE
15245 tolua_Error tolua_err;
15246 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Ident'",NULL);
15247 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
15248 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15249 #endif
15250 self->Ident = ((std::string) tolua_tocppstring(tolua_S,2,0))
15251 ;
15252 return 0;
15253 }
15254 #endif //#ifndef TOLUA_DISABLE
15255
15256 /* get function: Name of class CUnitType */
15257 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_Name
15258 static int tolua_get_CUnitType_Name(lua_State* tolua_S)
15259 {
15260 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15261 #ifndef TOLUA_RELEASE
15262 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
15263 #endif
15264 tolua_pushcppstring(tolua_S,(const char*)self->Name);
15265 return 1;
15266 }
15267 #endif //#ifndef TOLUA_DISABLE
15268
15269 /* set function: Name of class CUnitType */
15270 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_Name
15271 static int tolua_set_CUnitType_Name(lua_State* tolua_S)
15272 {
15273 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15274 #ifndef TOLUA_RELEASE
15275 tolua_Error tolua_err;
15276 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
15277 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
15278 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15279 #endif
15280 self->Name = ((std::string) tolua_tocppstring(tolua_S,2,0))
15281 ;
15282 return 0;
15283 }
15284 #endif //#ifndef TOLUA_DISABLE
15285
15286 /* get function: Slot of class CUnitType */
15287 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_Slot
15288 static int tolua_get_CUnitType_Slot(lua_State* tolua_S)
15289 {
15290 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15291 #ifndef TOLUA_RELEASE
15292 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Slot'",NULL);
15293 #endif
15294 tolua_pushnumber(tolua_S,(lua_Number)self->Slot);
15295 return 1;
15296 }
15297 #endif //#ifndef TOLUA_DISABLE
15298
15299 /* get function: MinAttackRange of class CUnitType */
15300 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_MinAttackRange
15301 static int tolua_get_CUnitType_MinAttackRange(lua_State* tolua_S)
15302 {
15303 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15304 #ifndef TOLUA_RELEASE
15305 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MinAttackRange'",NULL);
15306 #endif
15307 tolua_pushnumber(tolua_S,(lua_Number)self->MinAttackRange);
15308 return 1;
15309 }
15310 #endif //#ifndef TOLUA_DISABLE
15311
15312 /* set function: MinAttackRange of class CUnitType */
15313 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_MinAttackRange
15314 static int tolua_set_CUnitType_MinAttackRange(lua_State* tolua_S)
15315 {
15316 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15317 #ifndef TOLUA_RELEASE
15318 tolua_Error tolua_err;
15319 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MinAttackRange'",NULL);
15320 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15321 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15322 #endif
15323 self->MinAttackRange = ((int) tolua_tonumber(tolua_S,2,0))
15324 ;
15325 return 0;
15326 }
15327 #endif //#ifndef TOLUA_DISABLE
15328
15329 /* get function: MaxEnergyUtilizationRate of class CUnitType */
15330 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_MaxEnergyUtilizationRate
15331 static int tolua_get_CUnitType_MaxEnergyUtilizationRate(lua_State* tolua_S)
15332 {
15333 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15334 #ifndef TOLUA_RELEASE
15335 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxEnergyUtilizationRate'",NULL);
15336 #endif
15337 tolua_pushnumber(tolua_S,(lua_Number)self->GetMaxEnergyUtilizationRate());
15338 return 1;
15339 }
15340 #endif //#ifndef TOLUA_DISABLE
15341
15342 /* set function: MaxEnergyUtilizationRate of class CUnitType */
15343 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_MaxEnergyUtilizationRate
15344 static int tolua_set_CUnitType_MaxEnergyUtilizationRate(lua_State* tolua_S)
15345 {
15346 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15347 #ifndef TOLUA_RELEASE
15348 tolua_Error tolua_err;
15349 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxEnergyUtilizationRate'",NULL);
15350 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15351 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15352 #endif
15353 self->SetMaxEnergyUtilizationRate(((int) tolua_tonumber(tolua_S,2,0))
15354 )
15355 ;
15356 return 0;
15357 }
15358 #endif //#ifndef TOLUA_DISABLE
15359
15360 /* get function: MaxMagmaUtilizationRate of class CUnitType */
15361 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_MaxMagmaUtilizationRate
15362 static int tolua_get_CUnitType_MaxMagmaUtilizationRate(lua_State* tolua_S)
15363 {
15364 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15365 #ifndef TOLUA_RELEASE
15366 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxMagmaUtilizationRate'",NULL);
15367 #endif
15368 tolua_pushnumber(tolua_S,(lua_Number)self->GetMaxMagmaUtilizationRate());
15369 return 1;
15370 }
15371 #endif //#ifndef TOLUA_DISABLE
15372
15373 /* set function: MaxMagmaUtilizationRate of class CUnitType */
15374 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_MaxMagmaUtilizationRate
15375 static int tolua_set_CUnitType_MaxMagmaUtilizationRate(lua_State* tolua_S)
15376 {
15377 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15378 #ifndef TOLUA_RELEASE
15379 tolua_Error tolua_err;
15380 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxMagmaUtilizationRate'",NULL);
15381 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15382 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15383 #endif
15384 self->SetMaxMagmaUtilizationRate(((int) tolua_tonumber(tolua_S,2,0))
15385 )
15386 ;
15387 return 0;
15388 }
15389 #endif //#ifndef TOLUA_DISABLE
15390
15391 /* get function: EnergyProductionRate of class CUnitType */
15392 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_EnergyProductionRate
15393 static int tolua_get_CUnitType_EnergyProductionRate(lua_State* tolua_S)
15394 {
15395 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15396 #ifndef TOLUA_RELEASE
15397 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyProductionRate'",NULL);
15398 #endif
15399 tolua_pushnumber(tolua_S,(lua_Number)self->GetEnergyProductionRate());
15400 return 1;
15401 }
15402 #endif //#ifndef TOLUA_DISABLE
15403
15404 /* set function: EnergyProductionRate of class CUnitType */
15405 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_EnergyProductionRate
15406 static int tolua_set_CUnitType_EnergyProductionRate(lua_State* tolua_S)
15407 {
15408 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15409 #ifndef TOLUA_RELEASE
15410 tolua_Error tolua_err;
15411 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyProductionRate'",NULL);
15412 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15413 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15414 #endif
15415 self->SetEnergyProductionRate(((int) tolua_tonumber(tolua_S,2,0))
15416 )
15417 ;
15418 return 0;
15419 }
15420 #endif //#ifndef TOLUA_DISABLE
15421
15422 /* get function: MagmaProductionRate of class CUnitType */
15423 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_MagmaProductionRate
15424 static int tolua_get_CUnitType_MagmaProductionRate(lua_State* tolua_S)
15425 {
15426 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15427 #ifndef TOLUA_RELEASE
15428 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaProductionRate'",NULL);
15429 #endif
15430 tolua_pushnumber(tolua_S,(lua_Number)self->GetMagmaProductionRate());
15431 return 1;
15432 }
15433 #endif //#ifndef TOLUA_DISABLE
15434
15435 /* set function: MagmaProductionRate of class CUnitType */
15436 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_MagmaProductionRate
15437 static int tolua_set_CUnitType_MagmaProductionRate(lua_State* tolua_S)
15438 {
15439 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15440 #ifndef TOLUA_RELEASE
15441 tolua_Error tolua_err;
15442 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaProductionRate'",NULL);
15443 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15444 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15445 #endif
15446 self->SetMagmaProductionRate(((int) tolua_tonumber(tolua_S,2,0))
15447 )
15448 ;
15449 return 0;
15450 }
15451 #endif //#ifndef TOLUA_DISABLE
15452
15453 /* get function: EnergyValue of class CUnitType */
15454 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_EnergyValue
15455 static int tolua_get_CUnitType_EnergyValue(lua_State* tolua_S)
15456 {
15457 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15458 #ifndef TOLUA_RELEASE
15459 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyValue'",NULL);
15460 #endif
15461 tolua_pushnumber(tolua_S,(lua_Number)self->GetEnergyValue());
15462 return 1;
15463 }
15464 #endif //#ifndef TOLUA_DISABLE
15465
15466 /* set function: EnergyValue of class CUnitType */
15467 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_EnergyValue
15468 static int tolua_set_CUnitType_EnergyValue(lua_State* tolua_S)
15469 {
15470 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15471 #ifndef TOLUA_RELEASE
15472 tolua_Error tolua_err;
15473 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyValue'",NULL);
15474 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15475 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15476 #endif
15477 self->SetEnergyValue(((int) tolua_tonumber(tolua_S,2,0))
15478 )
15479 ;
15480 return 0;
15481 }
15482 #endif //#ifndef TOLUA_DISABLE
15483
15484 /* get function: MagmaValue of class CUnitType */
15485 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_MagmaValue
15486 static int tolua_get_CUnitType_MagmaValue(lua_State* tolua_S)
15487 {
15488 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15489 #ifndef TOLUA_RELEASE
15490 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaValue'",NULL);
15491 #endif
15492 tolua_pushnumber(tolua_S,(lua_Number)self->GetMagmaValue());
15493 return 1;
15494 }
15495 #endif //#ifndef TOLUA_DISABLE
15496
15497 /* set function: MagmaValue of class CUnitType */
15498 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_MagmaValue
15499 static int tolua_set_CUnitType_MagmaValue(lua_State* tolua_S)
15500 {
15501 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15502 #ifndef TOLUA_RELEASE
15503 tolua_Error tolua_err;
15504 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaValue'",NULL);
15505 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15506 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15507 #endif
15508 self->SetMagmaValue(((int) tolua_tonumber(tolua_S,2,0))
15509 )
15510 ;
15511 return 0;
15512 }
15513 #endif //#ifndef TOLUA_DISABLE
15514
15515 /* get function: EnergyStorageCapacity of class CUnitType */
15516 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_EnergyStorageCapacity
15517 static int tolua_get_CUnitType_EnergyStorageCapacity(lua_State* tolua_S)
15518 {
15519 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15520 #ifndef TOLUA_RELEASE
15521 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyStorageCapacity'",NULL);
15522 #endif
15523 tolua_pushnumber(tolua_S,(lua_Number)self->GetEnergyStorageCapacity());
15524 return 1;
15525 }
15526 #endif //#ifndef TOLUA_DISABLE
15527
15528 /* set function: EnergyStorageCapacity of class CUnitType */
15529 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_EnergyStorageCapacity
15530 static int tolua_set_CUnitType_EnergyStorageCapacity(lua_State* tolua_S)
15531 {
15532 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15533 #ifndef TOLUA_RELEASE
15534 tolua_Error tolua_err;
15535 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EnergyStorageCapacity'",NULL);
15536 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15537 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15538 #endif
15539 self->SetEnergyStorageCapacity(((int) tolua_tonumber(tolua_S,2,0))
15540 )
15541 ;
15542 return 0;
15543 }
15544 #endif //#ifndef TOLUA_DISABLE
15545
15546 /* get function: MagmaStorageCapacity of class CUnitType */
15547 #ifndef TOLUA_DISABLE_tolua_get_CUnitType_MagmaStorageCapacity
15548 static int tolua_get_CUnitType_MagmaStorageCapacity(lua_State* tolua_S)
15549 {
15550 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15551 #ifndef TOLUA_RELEASE
15552 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaStorageCapacity'",NULL);
15553 #endif
15554 tolua_pushnumber(tolua_S,(lua_Number)self->GetMagmaStorageCapacity());
15555 return 1;
15556 }
15557 #endif //#ifndef TOLUA_DISABLE
15558
15559 /* set function: MagmaStorageCapacity of class CUnitType */
15560 #ifndef TOLUA_DISABLE_tolua_set_CUnitType_MagmaStorageCapacity
15561 static int tolua_set_CUnitType_MagmaStorageCapacity(lua_State* tolua_S)
15562 {
15563 CUnitType* self = (CUnitType*) tolua_tousertype(tolua_S,1,0);
15564 #ifndef TOLUA_RELEASE
15565 tolua_Error tolua_err;
15566 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MagmaStorageCapacity'",NULL);
15567 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15568 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15569 #endif
15570 self->SetMagmaStorageCapacity(((int) tolua_tonumber(tolua_S,2,0))
15571 )
15572 ;
15573 return 0;
15574 }
15575 #endif //#ifndef TOLUA_DISABLE
15576
15577 /* function: UnitTypeByIdent */
15578 #ifndef TOLUA_DISABLE_tolua_stratagus_UnitTypeByIdent00
15579 static int tolua_stratagus_UnitTypeByIdent00(lua_State* tolua_S)
15580 {
15581 #ifndef TOLUA_RELEASE
15582 tolua_Error tolua_err;
15583 if (
15584 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
15585 !tolua_isnoobj(tolua_S,2,&tolua_err)
15586 )
15587 goto tolua_lerror;
15588 else
15589 #endif
15590 {
15591 const std::string ident = ((const std::string) tolua_tocppstring(tolua_S,1,0));
15592 {
15593 CUnitType* tolua_ret = (CUnitType*) UnitTypeByIdent(ident);
15594 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CUnitType");
15595 }
15596 }
15597 return 1;
15598 #ifndef TOLUA_RELEASE
15599 tolua_lerror:
15600 tolua_error(tolua_S,"#ferror in function 'UnitTypeByIdent'.",&tolua_err);
15601 return 0;
15602 #endif
15603 }
15604 #endif //#ifndef TOLUA_DISABLE
15605
15606 /* get function: Slot of class CUnit */
15607 #ifndef TOLUA_DISABLE_tolua_get_CUnit_Slot
15608 static int tolua_get_CUnit_Slot(lua_State* tolua_S)
15609 {
15610 CUnit* self = (CUnit*) tolua_tousertype(tolua_S,1,0);
15611 #ifndef TOLUA_RELEASE
15612 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Slot'",NULL);
15613 #endif
15614 tolua_pushnumber(tolua_S,(lua_Number)self->Slot);
15615 return 1;
15616 }
15617 #endif //#ifndef TOLUA_DISABLE
15618
15619 /* get function: X of class CUnit */
15620 #ifndef TOLUA_DISABLE_tolua_get_CUnit_X
15621 static int tolua_get_CUnit_X(lua_State* tolua_S)
15622 {
15623 CUnit* self = (CUnit*) tolua_tousertype(tolua_S,1,0);
15624 #ifndef TOLUA_RELEASE
15625 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
15626 #endif
15627 tolua_pushnumber(tolua_S,(lua_Number)self->X);
15628 return 1;
15629 }
15630 #endif //#ifndef TOLUA_DISABLE
15631
15632 /* set function: X of class CUnit */
15633 #ifndef TOLUA_DISABLE_tolua_set_CUnit_X
15634 static int tolua_set_CUnit_X(lua_State* tolua_S)
15635 {
15636 CUnit* self = (CUnit*) tolua_tousertype(tolua_S,1,0);
15637 #ifndef TOLUA_RELEASE
15638 tolua_Error tolua_err;
15639 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'X'",NULL);
15640 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15641 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15642 #endif
15643 self->X = ((int) tolua_tonumber(tolua_S,2,0))
15644 ;
15645 return 0;
15646 }
15647 #endif //#ifndef TOLUA_DISABLE
15648
15649 /* get function: Y of class CUnit */
15650 #ifndef TOLUA_DISABLE_tolua_get_CUnit_Y
15651 static int tolua_get_CUnit_Y(lua_State* tolua_S)
15652 {
15653 CUnit* self = (CUnit*) tolua_tousertype(tolua_S,1,0);
15654 #ifndef TOLUA_RELEASE
15655 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
15656 #endif
15657 tolua_pushnumber(tolua_S,(lua_Number)self->Y);
15658 return 1;
15659 }
15660 #endif //#ifndef TOLUA_DISABLE
15661
15662 /* set function: Y of class CUnit */
15663 #ifndef TOLUA_DISABLE_tolua_set_CUnit_Y
15664 static int tolua_set_CUnit_Y(lua_State* tolua_S)
15665 {
15666 CUnit* self = (CUnit*) tolua_tousertype(tolua_S,1,0);
15667 #ifndef TOLUA_RELEASE
15668 tolua_Error tolua_err;
15669 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Y'",NULL);
15670 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15671 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15672 #endif
15673 self->Y = ((int) tolua_tonumber(tolua_S,2,0))
15674 ;
15675 return 0;
15676 }
15677 #endif //#ifndef TOLUA_DISABLE
15678
15679 /* get function: Type of class CUnit */
15680 #ifndef TOLUA_DISABLE_tolua_get_CUnit_Type_ptr
15681 static int tolua_get_CUnit_Type_ptr(lua_State* tolua_S)
15682 {
15683 CUnit* self = (CUnit*) tolua_tousertype(tolua_S,1,0);
15684 #ifndef TOLUA_RELEASE
15685 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
15686 #endif
15687 tolua_pushusertype(tolua_S,(void*)self->Type,"CUnitType");
15688 return 1;
15689 }
15690 #endif //#ifndef TOLUA_DISABLE
15691
15692 /* set function: Type of class CUnit */
15693 #ifndef TOLUA_DISABLE_tolua_set_CUnit_Type_ptr
15694 static int tolua_set_CUnit_Type_ptr(lua_State* tolua_S)
15695 {
15696 CUnit* self = (CUnit*) tolua_tousertype(tolua_S,1,0);
15697 #ifndef TOLUA_RELEASE
15698 tolua_Error tolua_err;
15699 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
15700 if (!tolua_isusertype(tolua_S,2,"CUnitType",0,&tolua_err))
15701 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15702 #endif
15703 self->Type = ((CUnitType*) tolua_tousertype(tolua_S,2,0))
15704 ;
15705 return 0;
15706 }
15707 #endif //#ifndef TOLUA_DISABLE
15708
15709 /* get function: Player of class CUnit */
15710 #ifndef TOLUA_DISABLE_tolua_get_CUnit_Player_ptr
15711 static int tolua_get_CUnit_Player_ptr(lua_State* tolua_S)
15712 {
15713 CUnit* self = (CUnit*) tolua_tousertype(tolua_S,1,0);
15714 #ifndef TOLUA_RELEASE
15715 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Player'",NULL);
15716 #endif
15717 tolua_pushusertype(tolua_S,(void*)self->Player,"CPlayer");
15718 return 1;
15719 }
15720 #endif //#ifndef TOLUA_DISABLE
15721
15722 /* set function: Player of class CUnit */
15723 #ifndef TOLUA_DISABLE_tolua_set_CUnit_Player_ptr
15724 static int tolua_set_CUnit_Player_ptr(lua_State* tolua_S)
15725 {
15726 CUnit* self = (CUnit*) tolua_tousertype(tolua_S,1,0);
15727 #ifndef TOLUA_RELEASE
15728 tolua_Error tolua_err;
15729 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Player'",NULL);
15730 if (!tolua_isusertype(tolua_S,2,"CPlayer",0,&tolua_err))
15731 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15732 #endif
15733 self->Player = ((CPlayer*) tolua_tousertype(tolua_S,2,0))
15734 ;
15735 return 0;
15736 }
15737 #endif //#ifndef TOLUA_DISABLE
15738
15739 /* get function: ShowSightRange of class CPreference */
15740 #ifndef TOLUA_DISABLE_tolua_get_CPreference_ShowSightRange
15741 static int tolua_get_CPreference_ShowSightRange(lua_State* tolua_S)
15742 {
15743 CPreference* self = (CPreference*) tolua_tousertype(tolua_S,1,0);
15744 #ifndef TOLUA_RELEASE
15745 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowSightRange'",NULL);
15746 #endif
15747 tolua_pushboolean(tolua_S,(bool)self->ShowSightRange);
15748 return 1;
15749 }
15750 #endif //#ifndef TOLUA_DISABLE
15751
15752 /* set function: ShowSightRange of class CPreference */
15753 #ifndef TOLUA_DISABLE_tolua_set_CPreference_ShowSightRange
15754 static int tolua_set_CPreference_ShowSightRange(lua_State* tolua_S)
15755 {
15756 CPreference* self = (CPreference*) tolua_tousertype(tolua_S,1,0);
15757 #ifndef TOLUA_RELEASE
15758 tolua_Error tolua_err;
15759 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowSightRange'",NULL);
15760 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
15761 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15762 #endif
15763 self->ShowSightRange = ((bool) tolua_toboolean(tolua_S,2,0))
15764 ;
15765 return 0;
15766 }
15767 #endif //#ifndef TOLUA_DISABLE
15768
15769 /* get function: ShowReactionRange of class CPreference */
15770 #ifndef TOLUA_DISABLE_tolua_get_CPreference_ShowReactionRange
15771 static int tolua_get_CPreference_ShowReactionRange(lua_State* tolua_S)
15772 {
15773 CPreference* self = (CPreference*) tolua_tousertype(tolua_S,1,0);
15774 #ifndef TOLUA_RELEASE
15775 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowReactionRange'",NULL);
15776 #endif
15777 tolua_pushboolean(tolua_S,(bool)self->ShowReactionRange);
15778 return 1;
15779 }
15780 #endif //#ifndef TOLUA_DISABLE
15781
15782 /* set function: ShowReactionRange of class CPreference */
15783 #ifndef TOLUA_DISABLE_tolua_set_CPreference_ShowReactionRange
15784 static int tolua_set_CPreference_ShowReactionRange(lua_State* tolua_S)
15785 {
15786 CPreference* self = (CPreference*) tolua_tousertype(tolua_S,1,0);
15787 #ifndef TOLUA_RELEASE
15788 tolua_Error tolua_err;
15789 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowReactionRange'",NULL);
15790 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
15791 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15792 #endif
15793 self->ShowReactionRange = ((bool) tolua_toboolean(tolua_S,2,0))
15794 ;
15795 return 0;
15796 }
15797 #endif //#ifndef TOLUA_DISABLE
15798
15799 /* get function: ShowAttackRange of class CPreference */
15800 #ifndef TOLUA_DISABLE_tolua_get_CPreference_ShowAttackRange
15801 static int tolua_get_CPreference_ShowAttackRange(lua_State* tolua_S)
15802 {
15803 CPreference* self = (CPreference*) tolua_tousertype(tolua_S,1,0);
15804 #ifndef TOLUA_RELEASE
15805 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowAttackRange'",NULL);
15806 #endif
15807 tolua_pushboolean(tolua_S,(bool)self->ShowAttackRange);
15808 return 1;
15809 }
15810 #endif //#ifndef TOLUA_DISABLE
15811
15812 /* set function: ShowAttackRange of class CPreference */
15813 #ifndef TOLUA_DISABLE_tolua_set_CPreference_ShowAttackRange
15814 static int tolua_set_CPreference_ShowAttackRange(lua_State* tolua_S)
15815 {
15816 CPreference* self = (CPreference*) tolua_tousertype(tolua_S,1,0);
15817 #ifndef TOLUA_RELEASE
15818 tolua_Error tolua_err;
15819 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowAttackRange'",NULL);
15820 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
15821 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15822 #endif
15823 self->ShowAttackRange = ((bool) tolua_toboolean(tolua_S,2,0))
15824 ;
15825 return 0;
15826 }
15827 #endif //#ifndef TOLUA_DISABLE
15828
15829 /* get function: ShowOrders of class CPreference */
15830 #ifndef TOLUA_DISABLE_tolua_get_CPreference_unsigned_ShowOrders
15831 static int tolua_get_CPreference_unsigned_ShowOrders(lua_State* tolua_S)
15832 {
15833 CPreference* self = (CPreference*) tolua_tousertype(tolua_S,1,0);
15834 #ifndef TOLUA_RELEASE
15835 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowOrders'",NULL);
15836 #endif
15837 tolua_pushnumber(tolua_S,(lua_Number)self->ShowOrders);
15838 return 1;
15839 }
15840 #endif //#ifndef TOLUA_DISABLE
15841
15842 /* set function: ShowOrders of class CPreference */
15843 #ifndef TOLUA_DISABLE_tolua_set_CPreference_unsigned_ShowOrders
15844 static int tolua_set_CPreference_unsigned_ShowOrders(lua_State* tolua_S)
15845 {
15846 CPreference* self = (CPreference*) tolua_tousertype(tolua_S,1,0);
15847 #ifndef TOLUA_RELEASE
15848 tolua_Error tolua_err;
15849 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowOrders'",NULL);
15850 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
15851 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15852 #endif
15853 self->ShowOrders = ((unsigned int) tolua_tonumber(tolua_S,2,0))
15854 ;
15855 return 0;
15856 }
15857 #endif //#ifndef TOLUA_DISABLE
15858
15859 /* get function: Preference */
15860 #ifndef TOLUA_DISABLE_tolua_get_Preference
15861 static int tolua_get_Preference(lua_State* tolua_S)
15862 {
15863 tolua_pushusertype(tolua_S,(void*)&Preference,"CPreference");
15864 return 1;
15865 }
15866 #endif //#ifndef TOLUA_DISABLE
15867
15868 /* set function: Preference */
15869 #ifndef TOLUA_DISABLE_tolua_set_Preference
15870 static int tolua_set_Preference(lua_State* tolua_S)
15871 {
15872 #ifndef TOLUA_RELEASE
15873 tolua_Error tolua_err;
15874 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CPreference",0,&tolua_err)))
15875 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
15876 #endif
15877 Preference = *((CPreference*) tolua_tousertype(tolua_S,2,0))
15878 ;
15879 return 0;
15880 }
15881 #endif //#ifndef TOLUA_DISABLE
15882
15883 /* function: GetEffectsVolume */
15884 #ifndef TOLUA_DISABLE_tolua_stratagus_GetEffectsVolume00
15885 static int tolua_stratagus_GetEffectsVolume00(lua_State* tolua_S)
15886 {
15887 #ifndef TOLUA_RELEASE
15888 tolua_Error tolua_err;
15889 if (
15890 !tolua_isnoobj(tolua_S,1,&tolua_err)
15891 )
15892 goto tolua_lerror;
15893 else
15894 #endif
15895 {
15896 {
15897 int tolua_ret = (int) GetEffectsVolume();
15898 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
15899 }
15900 }
15901 return 1;
15902 #ifndef TOLUA_RELEASE
15903 tolua_lerror:
15904 tolua_error(tolua_S,"#ferror in function 'GetEffectsVolume'.",&tolua_err);
15905 return 0;
15906 #endif
15907 }
15908 #endif //#ifndef TOLUA_DISABLE
15909
15910 /* function: SetEffectsVolume */
15911 #ifndef TOLUA_DISABLE_tolua_stratagus_SetEffectsVolume00
15912 static int tolua_stratagus_SetEffectsVolume00(lua_State* tolua_S)
15913 {
15914 #ifndef TOLUA_RELEASE
15915 tolua_Error tolua_err;
15916 if (
15917 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
15918 !tolua_isnoobj(tolua_S,2,&tolua_err)
15919 )
15920 goto tolua_lerror;
15921 else
15922 #endif
15923 {
15924 int volume = ((int) tolua_tonumber(tolua_S,1,0));
15925 {
15926 SetEffectsVolume(volume);
15927 }
15928 }
15929 return 0;
15930 #ifndef TOLUA_RELEASE
15931 tolua_lerror:
15932 tolua_error(tolua_S,"#ferror in function 'SetEffectsVolume'.",&tolua_err);
15933 return 0;
15934 #endif
15935 }
15936 #endif //#ifndef TOLUA_DISABLE
15937
15938 /* function: GetMusicVolume */
15939 #ifndef TOLUA_DISABLE_tolua_stratagus_GetMusicVolume00
15940 static int tolua_stratagus_GetMusicVolume00(lua_State* tolua_S)
15941 {
15942 #ifndef TOLUA_RELEASE
15943 tolua_Error tolua_err;
15944 if (
15945 !tolua_isnoobj(tolua_S,1,&tolua_err)
15946 )
15947 goto tolua_lerror;
15948 else
15949 #endif
15950 {
15951 {
15952 int tolua_ret = (int) GetMusicVolume();
15953 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
15954 }
15955 }
15956 return 1;
15957 #ifndef TOLUA_RELEASE
15958 tolua_lerror:
15959 tolua_error(tolua_S,"#ferror in function 'GetMusicVolume'.",&tolua_err);
15960 return 0;
15961 #endif
15962 }
15963 #endif //#ifndef TOLUA_DISABLE
15964
15965 /* function: SetMusicVolume */
15966 #ifndef TOLUA_DISABLE_tolua_stratagus_SetMusicVolume00
15967 static int tolua_stratagus_SetMusicVolume00(lua_State* tolua_S)
15968 {
15969 #ifndef TOLUA_RELEASE
15970 tolua_Error tolua_err;
15971 if (
15972 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
15973 !tolua_isnoobj(tolua_S,2,&tolua_err)
15974 )
15975 goto tolua_lerror;
15976 else
15977 #endif
15978 {
15979 int volume = ((int) tolua_tonumber(tolua_S,1,0));
15980 {
15981 SetMusicVolume(volume);
15982 }
15983 }
15984 return 0;
15985 #ifndef TOLUA_RELEASE
15986 tolua_lerror:
15987 tolua_error(tolua_S,"#ferror in function 'SetMusicVolume'.",&tolua_err);
15988 return 0;
15989 #endif
15990 }
15991 #endif //#ifndef TOLUA_DISABLE
15992
15993 /* function: SetEffectsEnabled */
15994 #ifndef TOLUA_DISABLE_tolua_stratagus_SetEffectsEnabled00
15995 static int tolua_stratagus_SetEffectsEnabled00(lua_State* tolua_S)
15996 {
15997 #ifndef TOLUA_RELEASE
15998 tolua_Error tolua_err;
15999 if (
16000 !tolua_isboolean(tolua_S,1,0,&tolua_err) ||
16001 !tolua_isnoobj(tolua_S,2,&tolua_err)
16002 )
16003 goto tolua_lerror;
16004 else
16005 #endif
16006 {
16007 bool enabled = ((bool) tolua_toboolean(tolua_S,1,0));
16008 {
16009 SetEffectsEnabled(enabled);
16010 }
16011 }
16012 return 0;
16013 #ifndef TOLUA_RELEASE
16014 tolua_lerror:
16015 tolua_error(tolua_S,"#ferror in function 'SetEffectsEnabled'.",&tolua_err);
16016 return 0;
16017 #endif
16018 }
16019 #endif //#ifndef TOLUA_DISABLE
16020
16021 /* function: IsEffectsEnabled */
16022 #ifndef TOLUA_DISABLE_tolua_stratagus_IsEffectsEnabled00
16023 static int tolua_stratagus_IsEffectsEnabled00(lua_State* tolua_S)
16024 {
16025 #ifndef TOLUA_RELEASE
16026 tolua_Error tolua_err;
16027 if (
16028 !tolua_isnoobj(tolua_S,1,&tolua_err)
16029 )
16030 goto tolua_lerror;
16031 else
16032 #endif
16033 {
16034 {
16035 bool tolua_ret = (bool) IsEffectsEnabled();
16036 tolua_pushboolean(tolua_S,(bool)tolua_ret);
16037 }
16038 }
16039 return 1;
16040 #ifndef TOLUA_RELEASE
16041 tolua_lerror:
16042 tolua_error(tolua_S,"#ferror in function 'IsEffectsEnabled'.",&tolua_err);
16043 return 0;
16044 #endif
16045 }
16046 #endif //#ifndef TOLUA_DISABLE
16047
16048 /* function: SetMusicEnabled */
16049 #ifndef TOLUA_DISABLE_tolua_stratagus_SetMusicEnabled00
16050 static int tolua_stratagus_SetMusicEnabled00(lua_State* tolua_S)
16051 {
16052 #ifndef TOLUA_RELEASE
16053 tolua_Error tolua_err;
16054 if (
16055 !tolua_isboolean(tolua_S,1,0,&tolua_err) ||
16056 !tolua_isnoobj(tolua_S,2,&tolua_err)
16057 )
16058 goto tolua_lerror;
16059 else
16060 #endif
16061 {
16062 bool enabled = ((bool) tolua_toboolean(tolua_S,1,0));
16063 {
16064 SetMusicEnabled(enabled);
16065 }
16066 }
16067 return 0;
16068 #ifndef TOLUA_RELEASE
16069 tolua_lerror:
16070 tolua_error(tolua_S,"#ferror in function 'SetMusicEnabled'.",&tolua_err);
16071 return 0;
16072 #endif
16073 }
16074 #endif //#ifndef TOLUA_DISABLE
16075
16076 /* function: IsMusicEnabled */
16077 #ifndef TOLUA_DISABLE_tolua_stratagus_IsMusicEnabled00
16078 static int tolua_stratagus_IsMusicEnabled00(lua_State* tolua_S)
16079 {
16080 #ifndef TOLUA_RELEASE
16081 tolua_Error tolua_err;
16082 if (
16083 !tolua_isnoobj(tolua_S,1,&tolua_err)
16084 )
16085 goto tolua_lerror;
16086 else
16087 #endif
16088 {
16089 {
16090 bool tolua_ret = (bool) IsMusicEnabled();
16091 tolua_pushboolean(tolua_S,(bool)tolua_ret);
16092 }
16093 }
16094 return 1;
16095 #ifndef TOLUA_RELEASE
16096 tolua_lerror:
16097 tolua_error(tolua_S,"#ferror in function 'IsMusicEnabled'.",&tolua_err);
16098 return 0;
16099 #endif
16100 }
16101 #endif //#ifndef TOLUA_DISABLE
16102
16103 /* function: PlayFile */
16104 #ifndef TOLUA_DISABLE_tolua_stratagus_PlayFile00
16105 static int tolua_stratagus_PlayFile00(lua_State* tolua_S)
16106 {
16107 #ifndef TOLUA_RELEASE
16108 tolua_Error tolua_err;
16109 if (
16110 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16111 !tolua_isusertype(tolua_S,2,"LuaActionListener",1,&tolua_err) ||
16112 !tolua_isnoobj(tolua_S,3,&tolua_err)
16113 )
16114 goto tolua_lerror;
16115 else
16116 #endif
16117 {
16118 const std::string name = ((const std::string) tolua_tocppstring(tolua_S,1,0));
16119 LuaActionListener* listener = ((LuaActionListener*) tolua_tousertype(tolua_S,2,NULL));
16120 {
16121 int tolua_ret = (int) PlayFile(name,listener);
16122 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
16123 }
16124 }
16125 return 1;
16126 #ifndef TOLUA_RELEASE
16127 tolua_lerror:
16128 tolua_error(tolua_S,"#ferror in function 'PlayFile'.",&tolua_err);
16129 return 0;
16130 #endif
16131 }
16132 #endif //#ifndef TOLUA_DISABLE
16133
16134 /* function: PlayMusic */
16135 #ifndef TOLUA_DISABLE_tolua_stratagus_PlayMusic00
16136 static int tolua_stratagus_PlayMusic00(lua_State* tolua_S)
16137 {
16138 #ifndef TOLUA_RELEASE
16139 tolua_Error tolua_err;
16140 if (
16141 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16142 !tolua_isnoobj(tolua_S,2,&tolua_err)
16143 )
16144 goto tolua_lerror;
16145 else
16146 #endif
16147 {
16148 const std::string name = ((const std::string) tolua_tocppstring(tolua_S,1,0));
16149 {
16150 int tolua_ret = (int) PlayMusic(name);
16151 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
16152 }
16153 }
16154 return 1;
16155 #ifndef TOLUA_RELEASE
16156 tolua_lerror:
16157 tolua_error(tolua_S,"#ferror in function 'PlayMusic'.",&tolua_err);
16158 return 0;
16159 #endif
16160 }
16161 #endif //#ifndef TOLUA_DISABLE
16162
16163 /* function: StopMusic */
16164 #ifndef TOLUA_DISABLE_tolua_stratagus_StopMusic00
16165 static int tolua_stratagus_StopMusic00(lua_State* tolua_S)
16166 {
16167 #ifndef TOLUA_RELEASE
16168 tolua_Error tolua_err;
16169 if (
16170 !tolua_isnoobj(tolua_S,1,&tolua_err)
16171 )
16172 goto tolua_lerror;
16173 else
16174 #endif
16175 {
16176 {
16177 StopMusic();
16178 }
16179 }
16180 return 0;
16181 #ifndef TOLUA_RELEASE
16182 tolua_lerror:
16183 tolua_error(tolua_S,"#ferror in function 'StopMusic'.",&tolua_err);
16184 return 0;
16185 #endif
16186 }
16187 #endif //#ifndef TOLUA_DISABLE
16188
16189 /* function: SetChannelVolume */
16190 #ifndef TOLUA_DISABLE_tolua_stratagus_SetChannelVolume00
16191 static int tolua_stratagus_SetChannelVolume00(lua_State* tolua_S)
16192 {
16193 #ifndef TOLUA_RELEASE
16194 tolua_Error tolua_err;
16195 if (
16196 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
16197 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
16198 !tolua_isnoobj(tolua_S,3,&tolua_err)
16199 )
16200 goto tolua_lerror;
16201 else
16202 #endif
16203 {
16204 int channel = ((int) tolua_tonumber(tolua_S,1,0));
16205 int volume = ((int) tolua_tonumber(tolua_S,2,0));
16206 {
16207 int tolua_ret = (int) SetChannelVolume(channel,volume);
16208 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
16209 }
16210 }
16211 return 1;
16212 #ifndef TOLUA_RELEASE
16213 tolua_lerror:
16214 tolua_error(tolua_S,"#ferror in function 'SetChannelVolume'.",&tolua_err);
16215 return 0;
16216 #endif
16217 }
16218 #endif //#ifndef TOLUA_DISABLE
16219
16220 /* function: SetChannelStereo */
16221 #ifndef TOLUA_DISABLE_tolua_stratagus_SetChannelStereo00
16222 static int tolua_stratagus_SetChannelStereo00(lua_State* tolua_S)
16223 {
16224 #ifndef TOLUA_RELEASE
16225 tolua_Error tolua_err;
16226 if (
16227 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
16228 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
16229 !tolua_isnoobj(tolua_S,3,&tolua_err)
16230 )
16231 goto tolua_lerror;
16232 else
16233 #endif
16234 {
16235 int channel = ((int) tolua_tonumber(tolua_S,1,0));
16236 int stereo = ((int) tolua_tonumber(tolua_S,2,0));
16237 {
16238 int tolua_ret = (int) SetChannelStereo(channel,stereo);
16239 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
16240 }
16241 }
16242 return 1;
16243 #ifndef TOLUA_RELEASE
16244 tolua_lerror:
16245 tolua_error(tolua_S,"#ferror in function 'SetChannelStereo'.",&tolua_err);
16246 return 0;
16247 #endif
16248 }
16249 #endif //#ifndef TOLUA_DISABLE
16250
16251 /* function: StopChannel */
16252 #ifndef TOLUA_DISABLE_tolua_stratagus_StopChannel00
16253 static int tolua_stratagus_StopChannel00(lua_State* tolua_S)
16254 {
16255 #ifndef TOLUA_RELEASE
16256 tolua_Error tolua_err;
16257 if (
16258 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
16259 !tolua_isnoobj(tolua_S,2,&tolua_err)
16260 )
16261 goto tolua_lerror;
16262 else
16263 #endif
16264 {
16265 int channel = ((int) tolua_tonumber(tolua_S,1,0));
16266 {
16267 StopChannel(channel);
16268 }
16269 }
16270 return 0;
16271 #ifndef TOLUA_RELEASE
16272 tolua_lerror:
16273 tolua_error(tolua_S,"#ferror in function 'StopChannel'.",&tolua_err);
16274 return 0;
16275 #endif
16276 }
16277 #endif //#ifndef TOLUA_DISABLE
16278
16279 /* function: StopAllChannels */
16280 #ifndef TOLUA_DISABLE_tolua_stratagus_StopAllChannels00
16281 static int tolua_stratagus_StopAllChannels00(lua_State* tolua_S)
16282 {
16283 #ifndef TOLUA_RELEASE
16284 tolua_Error tolua_err;
16285 if (
16286 !tolua_isnoobj(tolua_S,1,&tolua_err)
16287 )
16288 goto tolua_lerror;
16289 else
16290 #endif
16291 {
16292 {
16293 StopAllChannels();
16294 }
16295 }
16296 return 0;
16297 #ifndef TOLUA_RELEASE
16298 tolua_lerror:
16299 tolua_error(tolua_S,"#ferror in function 'StopAllChannels'.",&tolua_err);
16300 return 0;
16301 #endif
16302 }
16303 #endif //#ifndef TOLUA_DISABLE
16304
16305 /* get function: UnitTypes of class CEditor */
16306 #ifndef TOLUA_DISABLE_tolua_get_CEditor_UnitTypes
16307 static int tolua_get_CEditor_UnitTypes(lua_State* tolua_S)
16308 {
16309 CEditor* self = (CEditor*) tolua_tousertype(tolua_S,1,0);
16310 #ifndef TOLUA_RELEASE
16311 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UnitTypes'",NULL);
16312 #endif
16313 tolua_pushusertype(tolua_S,(void*)&self->UnitTypes,"vector<string>");
16314 return 1;
16315 }
16316 #endif //#ifndef TOLUA_DISABLE
16317
16318 /* set function: UnitTypes of class CEditor */
16319 #ifndef TOLUA_DISABLE_tolua_set_CEditor_UnitTypes
16320 static int tolua_set_CEditor_UnitTypes(lua_State* tolua_S)
16321 {
16322 CEditor* self = (CEditor*) tolua_tousertype(tolua_S,1,0);
16323 #ifndef TOLUA_RELEASE
16324 tolua_Error tolua_err;
16325 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UnitTypes'",NULL);
16326 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"vector<string>",0,&tolua_err)))
16327 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
16328 #endif
16329 self->UnitTypes = *((vector<string>*) tolua_tousertype(tolua_S,2,0))
16330 ;
16331 return 0;
16332 }
16333 #endif //#ifndef TOLUA_DISABLE
16334
16335 /* get function: StartUnit of class CEditor */
16336 #ifndef TOLUA_DISABLE_tolua_get_CEditor_StartUnit_ptr
16337 static int tolua_get_CEditor_StartUnit_ptr(lua_State* tolua_S)
16338 {
16339 CEditor* self = (CEditor*) tolua_tousertype(tolua_S,1,0);
16340 #ifndef TOLUA_RELEASE
16341 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'StartUnit'",NULL);
16342 #endif
16343 tolua_pushusertype(tolua_S,(void*)self->StartUnit,"const CUnitType");
16344 return 1;
16345 }
16346 #endif //#ifndef TOLUA_DISABLE
16347
16348 /* get function: ShowTerrainFlags of class CEditor */
16349 #ifndef TOLUA_DISABLE_tolua_get_CEditor_ShowTerrainFlags
16350 static int tolua_get_CEditor_ShowTerrainFlags(lua_State* tolua_S)
16351 {
16352 CEditor* self = (CEditor*) tolua_tousertype(tolua_S,1,0);
16353 #ifndef TOLUA_RELEASE
16354 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowTerrainFlags'",NULL);
16355 #endif
16356 tolua_pushboolean(tolua_S,(bool)self->ShowTerrainFlags);
16357 return 1;
16358 }
16359 #endif //#ifndef TOLUA_DISABLE
16360
16361 /* set function: ShowTerrainFlags of class CEditor */
16362 #ifndef TOLUA_DISABLE_tolua_set_CEditor_ShowTerrainFlags
16363 static int tolua_set_CEditor_ShowTerrainFlags(lua_State* tolua_S)
16364 {
16365 CEditor* self = (CEditor*) tolua_tousertype(tolua_S,1,0);
16366 #ifndef TOLUA_RELEASE
16367 tolua_Error tolua_err;
16368 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ShowTerrainFlags'",NULL);
16369 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
16370 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
16371 #endif
16372 self->ShowTerrainFlags = ((bool) tolua_toboolean(tolua_S,2,0))
16373 ;
16374 return 0;
16375 }
16376 #endif //#ifndef TOLUA_DISABLE
16377
16378 /* get function: Running of class CEditor */
16379 #ifndef TOLUA_DISABLE_tolua_get_CEditor_Running
16380 static int tolua_get_CEditor_Running(lua_State* tolua_S)
16381 {
16382 CEditor* self = (CEditor*) tolua_tousertype(tolua_S,1,0);
16383 #ifndef TOLUA_RELEASE
16384 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Running'",NULL);
16385 #endif
16386 tolua_pushnumber(tolua_S,(lua_Number)self->Running);
16387 return 1;
16388 }
16389 #endif //#ifndef TOLUA_DISABLE
16390
16391 /* set function: Running of class CEditor */
16392 #ifndef TOLUA_DISABLE_tolua_set_CEditor_Running
16393 static int tolua_set_CEditor_Running(lua_State* tolua_S)
16394 {
16395 CEditor* self = (CEditor*) tolua_tousertype(tolua_S,1,0);
16396 #ifndef TOLUA_RELEASE
16397 tolua_Error tolua_err;
16398 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Running'",NULL);
16399 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
16400 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
16401 #endif
16402 self->Running = ((EditorRunningType) (int) tolua_tonumber(tolua_S,2,0))
16403 ;
16404 return 0;
16405 }
16406 #endif //#ifndef TOLUA_DISABLE
16407
16408 /* method: TileSelectedPatch of class CEditor */
16409 #ifndef TOLUA_DISABLE_tolua_stratagus_CEditor_TileSelectedPatch00
16410 static int tolua_stratagus_CEditor_TileSelectedPatch00(lua_State* tolua_S)
16411 {
16412 #ifndef TOLUA_RELEASE
16413 tolua_Error tolua_err;
16414 if (
16415 !tolua_isusertype(tolua_S,1,"CEditor",0,&tolua_err) ||
16416 !tolua_isnoobj(tolua_S,2,&tolua_err)
16417 )
16418 goto tolua_lerror;
16419 else
16420 #endif
16421 {
16422 CEditor* self = (CEditor*) tolua_tousertype(tolua_S,1,0);
16423 #ifndef TOLUA_RELEASE
16424 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TileSelectedPatch'", NULL);
16425 #endif
16426 {
16427 self->TileSelectedPatch();
16428 }
16429 }
16430 return 0;
16431 #ifndef TOLUA_RELEASE
16432 tolua_lerror:
16433 tolua_error(tolua_S,"#ferror in function 'TileSelectedPatch'.",&tolua_err);
16434 return 0;
16435 #endif
16436 }
16437 #endif //#ifndef TOLUA_DISABLE
16438
16439 /* function: SetEditorSelectIcon */
16440 #ifndef TOLUA_DISABLE_tolua_stratagus_SetEditorSelectIcon00
16441 static int tolua_stratagus_SetEditorSelectIcon00(lua_State* tolua_S)
16442 {
16443 #ifndef TOLUA_RELEASE
16444 tolua_Error tolua_err;
16445 if (
16446 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16447 !tolua_isnoobj(tolua_S,2,&tolua_err)
16448 )
16449 goto tolua_lerror;
16450 else
16451 #endif
16452 {
16453 std::string icon = ((std::string) tolua_tocppstring(tolua_S,1,0));
16454 {
16455 SetEditorSelectIcon(icon);
16456 }
16457 }
16458 return 0;
16459 #ifndef TOLUA_RELEASE
16460 tolua_lerror:
16461 tolua_error(tolua_S,"#ferror in function 'SetEditorSelectIcon'.",&tolua_err);
16462 return 0;
16463 #endif
16464 }
16465 #endif //#ifndef TOLUA_DISABLE
16466
16467 /* function: SetEditorUnitsIcon */
16468 #ifndef TOLUA_DISABLE_tolua_stratagus_SetEditorUnitsIcon00
16469 static int tolua_stratagus_SetEditorUnitsIcon00(lua_State* tolua_S)
16470 {
16471 #ifndef TOLUA_RELEASE
16472 tolua_Error tolua_err;
16473 if (
16474 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16475 !tolua_isnoobj(tolua_S,2,&tolua_err)
16476 )
16477 goto tolua_lerror;
16478 else
16479 #endif
16480 {
16481 std::string icon = ((std::string) tolua_tocppstring(tolua_S,1,0));
16482 {
16483 SetEditorUnitsIcon(icon);
16484 }
16485 }
16486 return 0;
16487 #ifndef TOLUA_RELEASE
16488 tolua_lerror:
16489 tolua_error(tolua_S,"#ferror in function 'SetEditorUnitsIcon'.",&tolua_err);
16490 return 0;
16491 #endif
16492 }
16493 #endif //#ifndef TOLUA_DISABLE
16494
16495 /* function: SetEditorPatchIcon */
16496 #ifndef TOLUA_DISABLE_tolua_stratagus_SetEditorPatchIcon00
16497 static int tolua_stratagus_SetEditorPatchIcon00(lua_State* tolua_S)
16498 {
16499 #ifndef TOLUA_RELEASE
16500 tolua_Error tolua_err;
16501 if (
16502 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16503 !tolua_isnoobj(tolua_S,2,&tolua_err)
16504 )
16505 goto tolua_lerror;
16506 else
16507 #endif
16508 {
16509 std::string icon = ((std::string) tolua_tocppstring(tolua_S,1,0));
16510 {
16511 SetEditorPatchIcon(icon);
16512 }
16513 }
16514 return 0;
16515 #ifndef TOLUA_RELEASE
16516 tolua_lerror:
16517 tolua_error(tolua_S,"#ferror in function 'SetEditorPatchIcon'.",&tolua_err);
16518 return 0;
16519 #endif
16520 }
16521 #endif //#ifndef TOLUA_DISABLE
16522
16523 /* function: SetEditorStartUnit */
16524 #ifndef TOLUA_DISABLE_tolua_stratagus_SetEditorStartUnit00
16525 static int tolua_stratagus_SetEditorStartUnit00(lua_State* tolua_S)
16526 {
16527 #ifndef TOLUA_RELEASE
16528 tolua_Error tolua_err;
16529 if (
16530 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16531 !tolua_isnoobj(tolua_S,2,&tolua_err)
16532 )
16533 goto tolua_lerror;
16534 else
16535 #endif
16536 {
16537 std::string name = ((std::string) tolua_tocppstring(tolua_S,1,0));
16538 {
16539 SetEditorStartUnit(name);
16540 }
16541 }
16542 return 0;
16543 #ifndef TOLUA_RELEASE
16544 tolua_lerror:
16545 tolua_error(tolua_S,"#ferror in function 'SetEditorStartUnit'.",&tolua_err);
16546 return 0;
16547 #endif
16548 }
16549 #endif //#ifndef TOLUA_DISABLE
16550
16551 /* get function: Editor */
16552 #ifndef TOLUA_DISABLE_tolua_get_Editor
16553 static int tolua_get_Editor(lua_State* tolua_S)
16554 {
16555 tolua_pushusertype(tolua_S,(void*)&Editor,"CEditor");
16556 return 1;
16557 }
16558 #endif //#ifndef TOLUA_DISABLE
16559
16560 /* set function: Editor */
16561 #ifndef TOLUA_DISABLE_tolua_set_Editor
16562 static int tolua_set_Editor(lua_State* tolua_S)
16563 {
16564 #ifndef TOLUA_RELEASE
16565 tolua_Error tolua_err;
16566 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CEditor",0,&tolua_err)))
16567 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
16568 #endif
16569 Editor = *((CEditor*) tolua_tousertype(tolua_S,2,0))
16570 ;
16571 return 0;
16572 }
16573 #endif //#ifndef TOLUA_DISABLE
16574
16575 /* function: StartEditor */
16576 #ifndef TOLUA_DISABLE_tolua_stratagus_StartEditor00
16577 static int tolua_stratagus_StartEditor00(lua_State* tolua_S)
16578 {
16579 #ifndef TOLUA_RELEASE
16580 tolua_Error tolua_err;
16581 if (
16582 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16583 !tolua_isnoobj(tolua_S,2,&tolua_err)
16584 )
16585 goto tolua_lerror;
16586 else
16587 #endif
16588 {
16589 std::string filename = ((std::string) tolua_tocppstring(tolua_S,1,0));
16590 {
16591 StartEditor(filename);
16592 }
16593 }
16594 return 0;
16595 #ifndef TOLUA_RELEASE
16596 tolua_lerror:
16597 tolua_error(tolua_S,"#ferror in function 'StartEditor'.",&tolua_err);
16598 return 0;
16599 #endif
16600 }
16601 #endif //#ifndef TOLUA_DISABLE
16602
16603 /* function: EditorSaveMap */
16604 #ifndef TOLUA_DISABLE_tolua_stratagus_EditorSaveMap00
16605 static int tolua_stratagus_EditorSaveMap00(lua_State* tolua_S)
16606 {
16607 #ifndef TOLUA_RELEASE
16608 tolua_Error tolua_err;
16609 if (
16610 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16611 !tolua_isnoobj(tolua_S,2,&tolua_err)
16612 )
16613 goto tolua_lerror;
16614 else
16615 #endif
16616 {
16617 std::string file = ((std::string) tolua_tocppstring(tolua_S,1,0));
16618 {
16619 int tolua_ret = (int) EditorSaveMap(file);
16620 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
16621 }
16622 }
16623 return 1;
16624 #ifndef TOLUA_RELEASE
16625 tolua_lerror:
16626 tolua_error(tolua_S,"#ferror in function 'EditorSaveMap'.",&tolua_err);
16627 return 0;
16628 #endif
16629 }
16630 #endif //#ifndef TOLUA_DISABLE
16631
16632 /* function: StartPatchEditor */
16633 #ifndef TOLUA_DISABLE_tolua_stratagus_StartPatchEditor00
16634 static int tolua_stratagus_StartPatchEditor00(lua_State* tolua_S)
16635 {
16636 #ifndef TOLUA_RELEASE
16637 tolua_Error tolua_err;
16638 if (
16639 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16640 !tolua_isnoobj(tolua_S,2,&tolua_err)
16641 )
16642 goto tolua_lerror;
16643 else
16644 #endif
16645 {
16646 std::string patchName = ((std::string) tolua_tocppstring(tolua_S,1,0));
16647 {
16648 StartPatchEditor(patchName);
16649 }
16650 }
16651 return 0;
16652 #ifndef TOLUA_RELEASE
16653 tolua_lerror:
16654 tolua_error(tolua_S,"#ferror in function 'StartPatchEditor'.",&tolua_err);
16655 return 0;
16656 #endif
16657 }
16658 #endif //#ifndef TOLUA_DISABLE
16659
16660 /* function: IsReplayGame */
16661 #ifndef TOLUA_DISABLE_tolua_stratagus_IsReplayGame00
16662 static int tolua_stratagus_IsReplayGame00(lua_State* tolua_S)
16663 {
16664 #ifndef TOLUA_RELEASE
16665 tolua_Error tolua_err;
16666 if (
16667 !tolua_isnoobj(tolua_S,1,&tolua_err)
16668 )
16669 goto tolua_lerror;
16670 else
16671 #endif
16672 {
16673 {
16674 bool tolua_ret = (bool) IsReplayGame();
16675 tolua_pushboolean(tolua_S,(bool)tolua_ret);
16676 }
16677 }
16678 return 1;
16679 #ifndef TOLUA_RELEASE
16680 tolua_lerror:
16681 tolua_error(tolua_S,"#ferror in function 'IsReplayGame'.",&tolua_err);
16682 return 0;
16683 #endif
16684 }
16685 #endif //#ifndef TOLUA_DISABLE
16686
16687 /* function: StartMap */
16688 #ifndef TOLUA_DISABLE_tolua_stratagus_StartMap00
16689 static int tolua_stratagus_StartMap00(lua_State* tolua_S)
16690 {
16691 #ifndef TOLUA_RELEASE
16692 tolua_Error tolua_err;
16693 if (
16694 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16695 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
16696 !tolua_isnoobj(tolua_S,3,&tolua_err)
16697 )
16698 goto tolua_lerror;
16699 else
16700 #endif
16701 {
16702 const string str = ((const string) tolua_tocppstring(tolua_S,1,0));
16703 bool clean = ((bool) tolua_toboolean(tolua_S,2,true));
16704 {
16705 StartMap(str,clean);
16706 }
16707 }
16708 return 0;
16709 #ifndef TOLUA_RELEASE
16710 tolua_lerror:
16711 tolua_error(tolua_S,"#ferror in function 'StartMap'.",&tolua_err);
16712 return 0;
16713 #endif
16714 }
16715 #endif //#ifndef TOLUA_DISABLE
16716
16717 /* function: StartReplay */
16718 #ifndef TOLUA_DISABLE_tolua_stratagus_StartReplay00
16719 static int tolua_stratagus_StartReplay00(lua_State* tolua_S)
16720 {
16721 #ifndef TOLUA_RELEASE
16722 tolua_Error tolua_err;
16723 if (
16724 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16725 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
16726 !tolua_isnoobj(tolua_S,3,&tolua_err)
16727 )
16728 goto tolua_lerror;
16729 else
16730 #endif
16731 {
16732 const string str = ((const string) tolua_tocppstring(tolua_S,1,0));
16733 bool reveal = ((bool) tolua_toboolean(tolua_S,2,false));
16734 {
16735 StartReplay(str,reveal);
16736 }
16737 }
16738 return 0;
16739 #ifndef TOLUA_RELEASE
16740 tolua_lerror:
16741 tolua_error(tolua_S,"#ferror in function 'StartReplay'.",&tolua_err);
16742 return 0;
16743 #endif
16744 }
16745 #endif //#ifndef TOLUA_DISABLE
16746
16747 /* function: StartSavedGame */
16748 #ifndef TOLUA_DISABLE_tolua_stratagus_StartSavedGame00
16749 static int tolua_stratagus_StartSavedGame00(lua_State* tolua_S)
16750 {
16751 #ifndef TOLUA_RELEASE
16752 tolua_Error tolua_err;
16753 if (
16754 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
16755 !tolua_isnoobj(tolua_S,2,&tolua_err)
16756 )
16757 goto tolua_lerror;
16758 else
16759 #endif
16760 {
16761 const string str = ((const string) tolua_tocppstring(tolua_S,1,0));
16762 {
16763 StartSavedGame(str);
16764 }
16765 }
16766 return 0;
16767 #ifndef TOLUA_RELEASE
16768 tolua_lerror:
16769 tolua_error(tolua_S,"#ferror in function 'StartSavedGame'.",&tolua_err);
16770 return 0;
16771 #endif
16772 }
16773 #endif //#ifndef TOLUA_DISABLE
16774
16775 /* get function: GameResult */
16776 #ifndef TOLUA_DISABLE_tolua_get_GameResult
16777 static int tolua_get_GameResult(lua_State* tolua_S)
16778 {
16779 tolua_pushnumber(tolua_S,(lua_Number)GameResult);
16780 return 1;
16781 }
16782 #endif //#ifndef TOLUA_DISABLE
16783
16784 /* set function: GameResult */
16785 #ifndef TOLUA_DISABLE_tolua_set_GameResult
16786 static int tolua_set_GameResult(lua_State* tolua_S)
16787 {
16788 #ifndef TOLUA_RELEASE
16789 tolua_Error tolua_err;
16790 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
16791 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
16792 #endif
16793 GameResult = ((GameResults) (int) tolua_tonumber(tolua_S,2,0))
16794 ;
16795 return 0;
16796 }
16797 #endif //#ifndef TOLUA_DISABLE
16798
16799 /* function: StopGame */
16800 #ifndef TOLUA_DISABLE_tolua_stratagus_StopGame00
16801 static int tolua_stratagus_StopGame00(lua_State* tolua_S)
16802 {
16803 #ifndef TOLUA_RELEASE
16804 tolua_Error tolua_err;
16805 if (
16806 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
16807 !tolua_isnoobj(tolua_S,2,&tolua_err)
16808 )
16809 goto tolua_lerror;
16810 else
16811 #endif
16812 {
16813 GameResults result = ((GameResults) (int) tolua_tonumber(tolua_S,1,0));
16814 {
16815 StopGame(result);
16816 }
16817 }
16818 return 0;
16819 #ifndef TOLUA_RELEASE
16820 tolua_lerror:
16821 tolua_error(tolua_S,"#ferror in function 'StopGame'.",&tolua_err);
16822 return 0;
16823 #endif
16824 }
16825 #endif //#ifndef TOLUA_DISABLE
16826
16827 /* get function: GameRunning */
16828 #ifndef TOLUA_DISABLE_tolua_get_GameRunning
16829 static int tolua_get_GameRunning(lua_State* tolua_S)
16830 {
16831 tolua_pushboolean(tolua_S,(bool)GameRunning);
16832 return 1;
16833 }
16834 #endif //#ifndef TOLUA_DISABLE
16835
16836 /* set function: GameRunning */
16837 #ifndef TOLUA_DISABLE_tolua_set_GameRunning
16838 static int tolua_set_GameRunning(lua_State* tolua_S)
16839 {
16840 #ifndef TOLUA_RELEASE
16841 tolua_Error tolua_err;
16842 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
16843 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
16844 #endif
16845 GameRunning = ((bool) tolua_toboolean(tolua_S,2,0))
16846 ;
16847 return 0;
16848 }
16849 #endif //#ifndef TOLUA_DISABLE
16850
16851 /* function: SetGamePaused */
16852 #ifndef TOLUA_DISABLE_tolua_stratagus_SetGamePaused00
16853 static int tolua_stratagus_SetGamePaused00(lua_State* tolua_S)
16854 {
16855 #ifndef TOLUA_RELEASE
16856 tolua_Error tolua_err;
16857 if (
16858 !tolua_isboolean(tolua_S,1,0,&tolua_err) ||
16859 !tolua_isnoobj(tolua_S,2,&tolua_err)
16860 )
16861 goto tolua_lerror;
16862 else
16863 #endif
16864 {
16865 bool paused = ((bool) tolua_toboolean(tolua_S,1,0));
16866 {
16867 SetGamePaused(paused);
16868 }
16869 }
16870 return 0;
16871 #ifndef TOLUA_RELEASE
16872 tolua_lerror:
16873 tolua_error(tolua_S,"#ferror in function 'SetGamePaused'.",&tolua_err);
16874 return 0;
16875 #endif
16876 }
16877 #endif //#ifndef TOLUA_DISABLE
16878
16879 /* function: GetGamePaused */
16880 #ifndef TOLUA_DISABLE_tolua_stratagus_GetGamePaused00
16881 static int tolua_stratagus_GetGamePaused00(lua_State* tolua_S)
16882 {
16883 #ifndef TOLUA_RELEASE
16884 tolua_Error tolua_err;
16885 if (
16886 !tolua_isnoobj(tolua_S,1,&tolua_err)
16887 )
16888 goto tolua_lerror;
16889 else
16890 #endif
16891 {
16892 {
16893 bool tolua_ret = (bool) GetGamePaused();
16894 tolua_pushboolean(tolua_S,(bool)tolua_ret);
16895 }
16896 }
16897 return 1;
16898 #ifndef TOLUA_RELEASE
16899 tolua_lerror:
16900 tolua_error(tolua_S,"#ferror in function 'GetGamePaused'.",&tolua_err);
16901 return 0;
16902 #endif
16903 }
16904 #endif //#ifndef TOLUA_DISABLE
16905
16906 /* get function: GamePaused */
16907 #ifndef TOLUA_DISABLE_tolua_get_GamePaused
16908 static int tolua_get_GamePaused(lua_State* tolua_S)
16909 {
16910 tolua_pushboolean(tolua_S,(bool)GetGamePaused());
16911 return 1;
16912 }
16913 #endif //#ifndef TOLUA_DISABLE
16914
16915 /* set function: GamePaused */
16916 #ifndef TOLUA_DISABLE_tolua_set_GamePaused
16917 static int tolua_set_GamePaused(lua_State* tolua_S)
16918 {
16919 #ifndef TOLUA_RELEASE
16920 tolua_Error tolua_err;
16921 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
16922 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
16923 #endif
16924 SetGamePaused(((bool) tolua_toboolean(tolua_S,2,0))
16925 )
16926 ;
16927 return 0;
16928 }
16929 #endif //#ifndef TOLUA_DISABLE
16930
16931 /* function: SetGameSpeed */
16932 #ifndef TOLUA_DISABLE_tolua_stratagus_SetGameSpeed00
16933 static int tolua_stratagus_SetGameSpeed00(lua_State* tolua_S)
16934 {
16935 #ifndef TOLUA_RELEASE
16936 tolua_Error tolua_err;
16937 if (
16938 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
16939 !tolua_isnoobj(tolua_S,2,&tolua_err)
16940 )
16941 goto tolua_lerror;
16942 else
16943 #endif
16944 {
16945 int speed = ((int) tolua_tonumber(tolua_S,1,0));
16946 {
16947 SetGameSpeed(speed);
16948 }
16949 }
16950 return 0;
16951 #ifndef TOLUA_RELEASE
16952 tolua_lerror:
16953 tolua_error(tolua_S,"#ferror in function 'SetGameSpeed'.",&tolua_err);
16954 return 0;
16955 #endif
16956 }
16957 #endif //#ifndef TOLUA_DISABLE
16958
16959 /* function: GetGameSpeed */
16960 #ifndef TOLUA_DISABLE_tolua_stratagus_GetGameSpeed00
16961 static int tolua_stratagus_GetGameSpeed00(lua_State* tolua_S)
16962 {
16963 #ifndef TOLUA_RELEASE
16964 tolua_Error tolua_err;
16965 if (
16966 !tolua_isnoobj(tolua_S,1,&tolua_err)
16967 )
16968 goto tolua_lerror;
16969 else
16970 #endif
16971 {
16972 {
16973 int tolua_ret = (int) GetGameSpeed();
16974 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
16975 }
16976 }
16977 return 1;
16978 #ifndef TOLUA_RELEASE
16979 tolua_lerror:
16980 tolua_error(tolua_S,"#ferror in function 'GetGameSpeed'.",&tolua_err);
16981 return 0;
16982 #endif
16983 }
16984 #endif //#ifndef TOLUA_DISABLE
16985
16986 /* get function: GameSpeed */
16987 #ifndef TOLUA_DISABLE_tolua_get_GameSpeed
16988 static int tolua_get_GameSpeed(lua_State* tolua_S)
16989 {
16990 tolua_pushnumber(tolua_S,(lua_Number)GetGameSpeed());
16991 return 1;
16992 }
16993 #endif //#ifndef TOLUA_DISABLE
16994
16995 /* set function: GameSpeed */
16996 #ifndef TOLUA_DISABLE_tolua_set_GameSpeed
16997 static int tolua_set_GameSpeed(lua_State* tolua_S)
16998 {
16999 #ifndef TOLUA_RELEASE
17000 tolua_Error tolua_err;
17001 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17002 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17003 #endif
17004 SetGameSpeed(((int) tolua_tonumber(tolua_S,2,0))
17005 )
17006 ;
17007 return 0;
17008 }
17009 #endif //#ifndef TOLUA_DISABLE
17010
17011 /* get function: GameObserve */
17012 #ifndef TOLUA_DISABLE_tolua_get_GameObserve
17013 static int tolua_get_GameObserve(lua_State* tolua_S)
17014 {
17015 tolua_pushboolean(tolua_S,(bool)GameObserve);
17016 return 1;
17017 }
17018 #endif //#ifndef TOLUA_DISABLE
17019
17020 /* set function: GameObserve */
17021 #ifndef TOLUA_DISABLE_tolua_set_GameObserve
17022 static int tolua_set_GameObserve(lua_State* tolua_S)
17023 {
17024 #ifndef TOLUA_RELEASE
17025 tolua_Error tolua_err;
17026 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
17027 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17028 #endif
17029 GameObserve = ((bool) tolua_toboolean(tolua_S,2,0))
17030 ;
17031 return 0;
17032 }
17033 #endif //#ifndef TOLUA_DISABLE
17034
17035 /* get function: GameCycle */
17036 #ifndef TOLUA_DISABLE_tolua_get_unsigned_GameCycle
17037 static int tolua_get_unsigned_GameCycle(lua_State* tolua_S)
17038 {
17039 tolua_pushnumber(tolua_S,(lua_Number)GameCycle);
17040 return 1;
17041 }
17042 #endif //#ifndef TOLUA_DISABLE
17043
17044 /* set function: GameCycle */
17045 #ifndef TOLUA_DISABLE_tolua_set_unsigned_GameCycle
17046 static int tolua_set_unsigned_GameCycle(lua_State* tolua_S)
17047 {
17048 #ifndef TOLUA_RELEASE
17049 tolua_Error tolua_err;
17050 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17051 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17052 #endif
17053 GameCycle = ((unsigned long) tolua_tonumber(tolua_S,2,0))
17054 ;
17055 return 0;
17056 }
17057 #endif //#ifndef TOLUA_DISABLE
17058
17059 /* get function: Team of class SettingsPresets */
17060 #ifndef TOLUA_DISABLE_tolua_get_SettingsPresets_Team
17061 static int tolua_get_SettingsPresets_Team(lua_State* tolua_S)
17062 {
17063 SettingsPresets* self = (SettingsPresets*) tolua_tousertype(tolua_S,1,0);
17064 #ifndef TOLUA_RELEASE
17065 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Team'",NULL);
17066 #endif
17067 tolua_pushnumber(tolua_S,(lua_Number)self->Team);
17068 return 1;
17069 }
17070 #endif //#ifndef TOLUA_DISABLE
17071
17072 /* set function: Team of class SettingsPresets */
17073 #ifndef TOLUA_DISABLE_tolua_set_SettingsPresets_Team
17074 static int tolua_set_SettingsPresets_Team(lua_State* tolua_S)
17075 {
17076 SettingsPresets* self = (SettingsPresets*) tolua_tousertype(tolua_S,1,0);
17077 #ifndef TOLUA_RELEASE
17078 tolua_Error tolua_err;
17079 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Team'",NULL);
17080 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17081 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17082 #endif
17083 self->Team = ((int) tolua_tonumber(tolua_S,2,0))
17084 ;
17085 return 0;
17086 }
17087 #endif //#ifndef TOLUA_DISABLE
17088
17089 /* get function: Type of class SettingsPresets */
17090 #ifndef TOLUA_DISABLE_tolua_get_SettingsPresets_Type
17091 static int tolua_get_SettingsPresets_Type(lua_State* tolua_S)
17092 {
17093 SettingsPresets* self = (SettingsPresets*) tolua_tousertype(tolua_S,1,0);
17094 #ifndef TOLUA_RELEASE
17095 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
17096 #endif
17097 tolua_pushnumber(tolua_S,(lua_Number)self->Type);
17098 return 1;
17099 }
17100 #endif //#ifndef TOLUA_DISABLE
17101
17102 /* set function: Type of class SettingsPresets */
17103 #ifndef TOLUA_DISABLE_tolua_set_SettingsPresets_Type
17104 static int tolua_set_SettingsPresets_Type(lua_State* tolua_S)
17105 {
17106 SettingsPresets* self = (SettingsPresets*) tolua_tousertype(tolua_S,1,0);
17107 #ifndef TOLUA_RELEASE
17108 tolua_Error tolua_err;
17109 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
17110 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17111 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17112 #endif
17113 self->Type = ((PlayerTypes) (int) tolua_tonumber(tolua_S,2,0))
17114 ;
17115 return 0;
17116 }
17117 #endif //#ifndef TOLUA_DISABLE
17118
17119 /* get function: NetGameType of class Settings */
17120 #ifndef TOLUA_DISABLE_tolua_get_Settings_NetGameType
17121 static int tolua_get_Settings_NetGameType(lua_State* tolua_S)
17122 {
17123 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17124 #ifndef TOLUA_RELEASE
17125 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NetGameType'",NULL);
17126 #endif
17127 tolua_pushnumber(tolua_S,(lua_Number)self->NetGameType);
17128 return 1;
17129 }
17130 #endif //#ifndef TOLUA_DISABLE
17131
17132 /* set function: NetGameType of class Settings */
17133 #ifndef TOLUA_DISABLE_tolua_set_Settings_NetGameType
17134 static int tolua_set_Settings_NetGameType(lua_State* tolua_S)
17135 {
17136 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17137 #ifndef TOLUA_RELEASE
17138 tolua_Error tolua_err;
17139 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NetGameType'",NULL);
17140 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17141 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17142 #endif
17143 self->NetGameType = ((int) tolua_tonumber(tolua_S,2,0))
17144 ;
17145 return 0;
17146 }
17147 #endif //#ifndef TOLUA_DISABLE
17148
17149 /* get function: Presets of class Settings */
17150 #ifndef TOLUA_DISABLE_tolua_get_stratagus_Settings_Presets
17151 static int tolua_get_stratagus_Settings_Presets(lua_State* tolua_S)
17152 {
17153 int tolua_index;
17154 Settings* self;
17155 lua_pushstring(tolua_S,".self");
17156 lua_rawget(tolua_S,1);
17157 self = (Settings*) lua_touserdata(tolua_S,-1);
17158 #ifndef TOLUA_RELEASE
17159 {
17160 tolua_Error tolua_err;
17161 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17162 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
17163 }
17164 #endif
17165 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
17166 #ifndef TOLUA_RELEASE
17167 if (tolua_index<0 || tolua_index>=PlayerMax)
17168 tolua_error(tolua_S,"array indexing out of range.",NULL);
17169 #endif
17170 tolua_pushusertype(tolua_S,(void*)&self->Presets[tolua_index],"SettingsPresets");
17171 return 1;
17172 }
17173 #endif //#ifndef TOLUA_DISABLE
17174
17175 /* set function: Presets of class Settings */
17176 #ifndef TOLUA_DISABLE_tolua_set_stratagus_Settings_Presets
17177 static int tolua_set_stratagus_Settings_Presets(lua_State* tolua_S)
17178 {
17179 int tolua_index;
17180 Settings* self;
17181 lua_pushstring(tolua_S,".self");
17182 lua_rawget(tolua_S,1);
17183 self = (Settings*) lua_touserdata(tolua_S,-1);
17184 #ifndef TOLUA_RELEASE
17185 {
17186 tolua_Error tolua_err;
17187 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17188 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
17189 }
17190 #endif
17191 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
17192 #ifndef TOLUA_RELEASE
17193 if (tolua_index<0 || tolua_index>=PlayerMax)
17194 tolua_error(tolua_S,"array indexing out of range.",NULL);
17195 #endif
17196 self->Presets[tolua_index] = *((SettingsPresets*) tolua_tousertype(tolua_S,3,0));
17197 return 0;
17198 }
17199 #endif //#ifndef TOLUA_DISABLE
17200
17201 /* get function: Resources of class Settings */
17202 #ifndef TOLUA_DISABLE_tolua_get_Settings_Resources
17203 static int tolua_get_Settings_Resources(lua_State* tolua_S)
17204 {
17205 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17206 #ifndef TOLUA_RELEASE
17207 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Resources'",NULL);
17208 #endif
17209 tolua_pushnumber(tolua_S,(lua_Number)self->Resources);
17210 return 1;
17211 }
17212 #endif //#ifndef TOLUA_DISABLE
17213
17214 /* set function: Resources of class Settings */
17215 #ifndef TOLUA_DISABLE_tolua_set_Settings_Resources
17216 static int tolua_set_Settings_Resources(lua_State* tolua_S)
17217 {
17218 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17219 #ifndef TOLUA_RELEASE
17220 tolua_Error tolua_err;
17221 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Resources'",NULL);
17222 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17223 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17224 #endif
17225 self->Resources = ((int) tolua_tonumber(tolua_S,2,0))
17226 ;
17227 return 0;
17228 }
17229 #endif //#ifndef TOLUA_DISABLE
17230
17231 /* get function: NumUnits of class Settings */
17232 #ifndef TOLUA_DISABLE_tolua_get_Settings_NumUnits
17233 static int tolua_get_Settings_NumUnits(lua_State* tolua_S)
17234 {
17235 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17236 #ifndef TOLUA_RELEASE
17237 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NumUnits'",NULL);
17238 #endif
17239 tolua_pushnumber(tolua_S,(lua_Number)self->NumUnits);
17240 return 1;
17241 }
17242 #endif //#ifndef TOLUA_DISABLE
17243
17244 /* set function: NumUnits of class Settings */
17245 #ifndef TOLUA_DISABLE_tolua_set_Settings_NumUnits
17246 static int tolua_set_Settings_NumUnits(lua_State* tolua_S)
17247 {
17248 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17249 #ifndef TOLUA_RELEASE
17250 tolua_Error tolua_err;
17251 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NumUnits'",NULL);
17252 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17253 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17254 #endif
17255 self->NumUnits = ((int) tolua_tonumber(tolua_S,2,0))
17256 ;
17257 return 0;
17258 }
17259 #endif //#ifndef TOLUA_DISABLE
17260
17261 /* get function: Opponents of class Settings */
17262 #ifndef TOLUA_DISABLE_tolua_get_Settings_Opponents
17263 static int tolua_get_Settings_Opponents(lua_State* tolua_S)
17264 {
17265 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17266 #ifndef TOLUA_RELEASE
17267 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Opponents'",NULL);
17268 #endif
17269 tolua_pushnumber(tolua_S,(lua_Number)self->Opponents);
17270 return 1;
17271 }
17272 #endif //#ifndef TOLUA_DISABLE
17273
17274 /* set function: Opponents of class Settings */
17275 #ifndef TOLUA_DISABLE_tolua_set_Settings_Opponents
17276 static int tolua_set_Settings_Opponents(lua_State* tolua_S)
17277 {
17278 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17279 #ifndef TOLUA_RELEASE
17280 tolua_Error tolua_err;
17281 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Opponents'",NULL);
17282 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17283 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17284 #endif
17285 self->Opponents = ((int) tolua_tonumber(tolua_S,2,0))
17286 ;
17287 return 0;
17288 }
17289 #endif //#ifndef TOLUA_DISABLE
17290
17291 /* get function: Difficulty of class Settings */
17292 #ifndef TOLUA_DISABLE_tolua_get_Settings_Difficulty
17293 static int tolua_get_Settings_Difficulty(lua_State* tolua_S)
17294 {
17295 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17296 #ifndef TOLUA_RELEASE
17297 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Difficulty'",NULL);
17298 #endif
17299 tolua_pushnumber(tolua_S,(lua_Number)self->Difficulty);
17300 return 1;
17301 }
17302 #endif //#ifndef TOLUA_DISABLE
17303
17304 /* set function: Difficulty of class Settings */
17305 #ifndef TOLUA_DISABLE_tolua_set_Settings_Difficulty
17306 static int tolua_set_Settings_Difficulty(lua_State* tolua_S)
17307 {
17308 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17309 #ifndef TOLUA_RELEASE
17310 tolua_Error tolua_err;
17311 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Difficulty'",NULL);
17312 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17313 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17314 #endif
17315 self->Difficulty = ((int) tolua_tonumber(tolua_S,2,0))
17316 ;
17317 return 0;
17318 }
17319 #endif //#ifndef TOLUA_DISABLE
17320
17321 /* get function: GameType of class Settings */
17322 #ifndef TOLUA_DISABLE_tolua_get_Settings_GameType
17323 static int tolua_get_Settings_GameType(lua_State* tolua_S)
17324 {
17325 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17326 #ifndef TOLUA_RELEASE
17327 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GameType'",NULL);
17328 #endif
17329 tolua_pushnumber(tolua_S,(lua_Number)self->GameType);
17330 return 1;
17331 }
17332 #endif //#ifndef TOLUA_DISABLE
17333
17334 /* set function: GameType of class Settings */
17335 #ifndef TOLUA_DISABLE_tolua_set_Settings_GameType
17336 static int tolua_set_Settings_GameType(lua_State* tolua_S)
17337 {
17338 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17339 #ifndef TOLUA_RELEASE
17340 tolua_Error tolua_err;
17341 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GameType'",NULL);
17342 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17343 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17344 #endif
17345 self->GameType = ((int) tolua_tonumber(tolua_S,2,0))
17346 ;
17347 return 0;
17348 }
17349 #endif //#ifndef TOLUA_DISABLE
17350
17351 /* get function: NoFogOfWar of class Settings */
17352 #ifndef TOLUA_DISABLE_tolua_get_Settings_NoFogOfWar
17353 static int tolua_get_Settings_NoFogOfWar(lua_State* tolua_S)
17354 {
17355 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17356 #ifndef TOLUA_RELEASE
17357 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NoFogOfWar'",NULL);
17358 #endif
17359 tolua_pushboolean(tolua_S,(bool)self->NoFogOfWar);
17360 return 1;
17361 }
17362 #endif //#ifndef TOLUA_DISABLE
17363
17364 /* set function: NoFogOfWar of class Settings */
17365 #ifndef TOLUA_DISABLE_tolua_set_Settings_NoFogOfWar
17366 static int tolua_set_Settings_NoFogOfWar(lua_State* tolua_S)
17367 {
17368 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17369 #ifndef TOLUA_RELEASE
17370 tolua_Error tolua_err;
17371 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NoFogOfWar'",NULL);
17372 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
17373 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17374 #endif
17375 self->NoFogOfWar = ((bool) tolua_toboolean(tolua_S,2,0))
17376 ;
17377 return 0;
17378 }
17379 #endif //#ifndef TOLUA_DISABLE
17380
17381 /* get function: RevealMap of class Settings */
17382 #ifndef TOLUA_DISABLE_tolua_get_Settings_RevealMap
17383 static int tolua_get_Settings_RevealMap(lua_State* tolua_S)
17384 {
17385 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17386 #ifndef TOLUA_RELEASE
17387 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RevealMap'",NULL);
17388 #endif
17389 tolua_pushnumber(tolua_S,(lua_Number)self->RevealMap);
17390 return 1;
17391 }
17392 #endif //#ifndef TOLUA_DISABLE
17393
17394 /* set function: RevealMap of class Settings */
17395 #ifndef TOLUA_DISABLE_tolua_set_Settings_RevealMap
17396 static int tolua_set_Settings_RevealMap(lua_State* tolua_S)
17397 {
17398 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17399 #ifndef TOLUA_RELEASE
17400 tolua_Error tolua_err;
17401 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RevealMap'",NULL);
17402 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17403 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17404 #endif
17405 self->RevealMap = ((int) tolua_tonumber(tolua_S,2,0))
17406 ;
17407 return 0;
17408 }
17409 #endif //#ifndef TOLUA_DISABLE
17410
17411 /* get function: MapRichness of class Settings */
17412 #ifndef TOLUA_DISABLE_tolua_get_Settings_MapRichness
17413 static int tolua_get_Settings_MapRichness(lua_State* tolua_S)
17414 {
17415 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17416 #ifndef TOLUA_RELEASE
17417 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapRichness'",NULL);
17418 #endif
17419 tolua_pushnumber(tolua_S,(lua_Number)self->MapRichness);
17420 return 1;
17421 }
17422 #endif //#ifndef TOLUA_DISABLE
17423
17424 /* set function: MapRichness of class Settings */
17425 #ifndef TOLUA_DISABLE_tolua_set_Settings_MapRichness
17426 static int tolua_set_Settings_MapRichness(lua_State* tolua_S)
17427 {
17428 Settings* self = (Settings*) tolua_tousertype(tolua_S,1,0);
17429 #ifndef TOLUA_RELEASE
17430 tolua_Error tolua_err;
17431 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapRichness'",NULL);
17432 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17433 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17434 #endif
17435 self->MapRichness = ((int) tolua_tonumber(tolua_S,2,0))
17436 ;
17437 return 0;
17438 }
17439 #endif //#ifndef TOLUA_DISABLE
17440
17441 /* get function: GameSettings */
17442 #ifndef TOLUA_DISABLE_tolua_get_GameSettings
17443 static int tolua_get_GameSettings(lua_State* tolua_S)
17444 {
17445 tolua_pushusertype(tolua_S,(void*)&GameSettings,"Settings");
17446 return 1;
17447 }
17448 #endif //#ifndef TOLUA_DISABLE
17449
17450 /* set function: GameSettings */
17451 #ifndef TOLUA_DISABLE_tolua_set_GameSettings
17452 static int tolua_set_GameSettings(lua_State* tolua_S)
17453 {
17454 #ifndef TOLUA_RELEASE
17455 tolua_Error tolua_err;
17456 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Settings",0,&tolua_err)))
17457 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17458 #endif
17459 GameSettings = *((Settings*) tolua_tousertype(tolua_S,2,0))
17460 ;
17461 return 0;
17462 }
17463 #endif //#ifndef TOLUA_DISABLE
17464
17465 /* get function: AlliedUnitRecyclingEfficiency */
17466 #ifndef TOLUA_DISABLE_tolua_get_stratagus_AlliedUnitRecyclingEfficiency
17467 static int tolua_get_stratagus_AlliedUnitRecyclingEfficiency(lua_State* tolua_S)
17468 {
17469 int tolua_index;
17470 #ifndef TOLUA_RELEASE
17471 {
17472 tolua_Error tolua_err;
17473 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17474 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
17475 }
17476 #endif
17477 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
17478 #ifndef TOLUA_RELEASE
17479 if (tolua_index<0 || tolua_index>=MaxCosts)
17480 tolua_error(tolua_S,"array indexing out of range.",NULL);
17481 #endif
17482 tolua_pushnumber(tolua_S,(lua_Number)AlliedUnitRecyclingEfficiency[tolua_index]);
17483 return 1;
17484 }
17485 #endif //#ifndef TOLUA_DISABLE
17486
17487 /* set function: AlliedUnitRecyclingEfficiency */
17488 #ifndef TOLUA_DISABLE_tolua_set_stratagus_AlliedUnitRecyclingEfficiency
17489 static int tolua_set_stratagus_AlliedUnitRecyclingEfficiency(lua_State* tolua_S)
17490 {
17491 int tolua_index;
17492 #ifndef TOLUA_RELEASE
17493 {
17494 tolua_Error tolua_err;
17495 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17496 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
17497 }
17498 #endif
17499 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
17500 #ifndef TOLUA_RELEASE
17501 if (tolua_index<0 || tolua_index>=MaxCosts)
17502 tolua_error(tolua_S,"array indexing out of range.",NULL);
17503 #endif
17504 AlliedUnitRecyclingEfficiency[tolua_index] = ((int) tolua_tonumber(tolua_S,3,0));
17505 return 0;
17506 }
17507 #endif //#ifndef TOLUA_DISABLE
17508
17509 /* get function: EnemyUnitRecyclingEfficiency */
17510 #ifndef TOLUA_DISABLE_tolua_get_stratagus_EnemyUnitRecyclingEfficiency
17511 static int tolua_get_stratagus_EnemyUnitRecyclingEfficiency(lua_State* tolua_S)
17512 {
17513 int tolua_index;
17514 #ifndef TOLUA_RELEASE
17515 {
17516 tolua_Error tolua_err;
17517 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17518 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
17519 }
17520 #endif
17521 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
17522 #ifndef TOLUA_RELEASE
17523 if (tolua_index<0 || tolua_index>=MaxCosts)
17524 tolua_error(tolua_S,"array indexing out of range.",NULL);
17525 #endif
17526 tolua_pushnumber(tolua_S,(lua_Number)EnemyUnitRecyclingEfficiency[tolua_index]);
17527 return 1;
17528 }
17529 #endif //#ifndef TOLUA_DISABLE
17530
17531 /* set function: EnemyUnitRecyclingEfficiency */
17532 #ifndef TOLUA_DISABLE_tolua_set_stratagus_EnemyUnitRecyclingEfficiency
17533 static int tolua_set_stratagus_EnemyUnitRecyclingEfficiency(lua_State* tolua_S)
17534 {
17535 int tolua_index;
17536 #ifndef TOLUA_RELEASE
17537 {
17538 tolua_Error tolua_err;
17539 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17540 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
17541 }
17542 #endif
17543 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
17544 #ifndef TOLUA_RELEASE
17545 if (tolua_index<0 || tolua_index>=MaxCosts)
17546 tolua_error(tolua_S,"array indexing out of range.",NULL);
17547 #endif
17548 EnemyUnitRecyclingEfficiency[tolua_index] = ((int) tolua_tonumber(tolua_S,3,0));
17549 return 0;
17550 }
17551 #endif //#ifndef TOLUA_DISABLE
17552
17553 /* get function: Description of class CMapInfo */
17554 #ifndef TOLUA_DISABLE_tolua_get_CMapInfo_Description
17555 static int tolua_get_CMapInfo_Description(lua_State* tolua_S)
17556 {
17557 CMapInfo* self = (CMapInfo*) tolua_tousertype(tolua_S,1,0);
17558 #ifndef TOLUA_RELEASE
17559 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Description'",NULL);
17560 #endif
17561 tolua_pushcppstring(tolua_S,(const char*)self->Description);
17562 return 1;
17563 }
17564 #endif //#ifndef TOLUA_DISABLE
17565
17566 /* set function: Description of class CMapInfo */
17567 #ifndef TOLUA_DISABLE_tolua_set_CMapInfo_Description
17568 static int tolua_set_CMapInfo_Description(lua_State* tolua_S)
17569 {
17570 CMapInfo* self = (CMapInfo*) tolua_tousertype(tolua_S,1,0);
17571 #ifndef TOLUA_RELEASE
17572 tolua_Error tolua_err;
17573 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Description'",NULL);
17574 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
17575 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17576 #endif
17577 self->Description = ((string) tolua_tocppstring(tolua_S,2,0))
17578 ;
17579 return 0;
17580 }
17581 #endif //#ifndef TOLUA_DISABLE
17582
17583 /* get function: MapWidth of class CMapInfo */
17584 #ifndef TOLUA_DISABLE_tolua_get_CMapInfo_MapWidth
17585 static int tolua_get_CMapInfo_MapWidth(lua_State* tolua_S)
17586 {
17587 CMapInfo* self = (CMapInfo*) tolua_tousertype(tolua_S,1,0);
17588 #ifndef TOLUA_RELEASE
17589 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapWidth'",NULL);
17590 #endif
17591 tolua_pushnumber(tolua_S,(lua_Number)self->MapWidth);
17592 return 1;
17593 }
17594 #endif //#ifndef TOLUA_DISABLE
17595
17596 /* set function: MapWidth of class CMapInfo */
17597 #ifndef TOLUA_DISABLE_tolua_set_CMapInfo_MapWidth
17598 static int tolua_set_CMapInfo_MapWidth(lua_State* tolua_S)
17599 {
17600 CMapInfo* self = (CMapInfo*) tolua_tousertype(tolua_S,1,0);
17601 #ifndef TOLUA_RELEASE
17602 tolua_Error tolua_err;
17603 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapWidth'",NULL);
17604 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17605 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17606 #endif
17607 self->MapWidth = ((int) tolua_tonumber(tolua_S,2,0))
17608 ;
17609 return 0;
17610 }
17611 #endif //#ifndef TOLUA_DISABLE
17612
17613 /* get function: MapHeight of class CMapInfo */
17614 #ifndef TOLUA_DISABLE_tolua_get_CMapInfo_MapHeight
17615 static int tolua_get_CMapInfo_MapHeight(lua_State* tolua_S)
17616 {
17617 CMapInfo* self = (CMapInfo*) tolua_tousertype(tolua_S,1,0);
17618 #ifndef TOLUA_RELEASE
17619 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapHeight'",NULL);
17620 #endif
17621 tolua_pushnumber(tolua_S,(lua_Number)self->MapHeight);
17622 return 1;
17623 }
17624 #endif //#ifndef TOLUA_DISABLE
17625
17626 /* set function: MapHeight of class CMapInfo */
17627 #ifndef TOLUA_DISABLE_tolua_set_CMapInfo_MapHeight
17628 static int tolua_set_CMapInfo_MapHeight(lua_State* tolua_S)
17629 {
17630 CMapInfo* self = (CMapInfo*) tolua_tousertype(tolua_S,1,0);
17631 #ifndef TOLUA_RELEASE
17632 tolua_Error tolua_err;
17633 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MapHeight'",NULL);
17634 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17635 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17636 #endif
17637 self->MapHeight = ((int) tolua_tonumber(tolua_S,2,0))
17638 ;
17639 return 0;
17640 }
17641 #endif //#ifndef TOLUA_DISABLE
17642
17643 /* get function: PlayerType of class CMapInfo */
17644 #ifndef TOLUA_DISABLE_tolua_get_stratagus_CMapInfo_PlayerType
17645 static int tolua_get_stratagus_CMapInfo_PlayerType(lua_State* tolua_S)
17646 {
17647 int tolua_index;
17648 CMapInfo* self;
17649 lua_pushstring(tolua_S,".self");
17650 lua_rawget(tolua_S,1);
17651 self = (CMapInfo*) lua_touserdata(tolua_S,-1);
17652 #ifndef TOLUA_RELEASE
17653 {
17654 tolua_Error tolua_err;
17655 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17656 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
17657 }
17658 #endif
17659 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
17660 #ifndef TOLUA_RELEASE
17661 if (tolua_index<0 || tolua_index>=PlayerMax)
17662 tolua_error(tolua_S,"array indexing out of range.",NULL);
17663 #endif
17664 tolua_pushnumber(tolua_S,(lua_Number)self->PlayerType[tolua_index]);
17665 return 1;
17666 }
17667 #endif //#ifndef TOLUA_DISABLE
17668
17669 /* set function: PlayerType of class CMapInfo */
17670 #ifndef TOLUA_DISABLE_tolua_set_stratagus_CMapInfo_PlayerType
17671 static int tolua_set_stratagus_CMapInfo_PlayerType(lua_State* tolua_S)
17672 {
17673 int tolua_index;
17674 CMapInfo* self;
17675 lua_pushstring(tolua_S,".self");
17676 lua_rawget(tolua_S,1);
17677 self = (CMapInfo*) lua_touserdata(tolua_S,-1);
17678 #ifndef TOLUA_RELEASE
17679 {
17680 tolua_Error tolua_err;
17681 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
17682 tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
17683 }
17684 #endif
17685 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
17686 #ifndef TOLUA_RELEASE
17687 if (tolua_index<0 || tolua_index>=PlayerMax)
17688 tolua_error(tolua_S,"array indexing out of range.",NULL);
17689 #endif
17690 self->PlayerType[tolua_index] = ((int) tolua_tonumber(tolua_S,3,0));
17691 return 0;
17692 }
17693 #endif //#ifndef TOLUA_DISABLE
17694
17695 /* get function: Info of class CMap */
17696 #ifndef TOLUA_DISABLE_tolua_get_CMap_Info
17697 static int tolua_get_CMap_Info(lua_State* tolua_S)
17698 {
17699 CMap* self = (CMap*) tolua_tousertype(tolua_S,1,0);
17700 #ifndef TOLUA_RELEASE
17701 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Info'",NULL);
17702 #endif
17703 tolua_pushusertype(tolua_S,(void*)&self->Info,"CMapInfo");
17704 return 1;
17705 }
17706 #endif //#ifndef TOLUA_DISABLE
17707
17708 /* set function: Info of class CMap */
17709 #ifndef TOLUA_DISABLE_tolua_set_CMap_Info
17710 static int tolua_set_CMap_Info(lua_State* tolua_S)
17711 {
17712 CMap* self = (CMap*) tolua_tousertype(tolua_S,1,0);
17713 #ifndef TOLUA_RELEASE
17714 tolua_Error tolua_err;
17715 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Info'",NULL);
17716 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CMapInfo",0,&tolua_err)))
17717 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17718 #endif
17719 self->Info = *((CMapInfo*) tolua_tousertype(tolua_S,2,0))
17720 ;
17721 return 0;
17722 }
17723 #endif //#ifndef TOLUA_DISABLE
17724
17725 /* get function: PatchManager of class CMap */
17726 #ifndef TOLUA_DISABLE_tolua_get_CMap_PatchManager
17727 static int tolua_get_CMap_PatchManager(lua_State* tolua_S)
17728 {
17729 CMap* self = (CMap*) tolua_tousertype(tolua_S,1,0);
17730 #ifndef TOLUA_RELEASE
17731 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PatchManager'",NULL);
17732 #endif
17733 tolua_pushusertype(tolua_S,(void*)&self->PatchManager,"CPatchManager");
17734 return 1;
17735 }
17736 #endif //#ifndef TOLUA_DISABLE
17737
17738 /* set function: PatchManager of class CMap */
17739 #ifndef TOLUA_DISABLE_tolua_set_CMap_PatchManager
17740 static int tolua_set_CMap_PatchManager(lua_State* tolua_S)
17741 {
17742 CMap* self = (CMap*) tolua_tousertype(tolua_S,1,0);
17743 #ifndef TOLUA_RELEASE
17744 tolua_Error tolua_err;
17745 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PatchManager'",NULL);
17746 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CPatchManager",0,&tolua_err)))
17747 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17748 #endif
17749 self->PatchManager = *((CPatchManager*) tolua_tousertype(tolua_S,2,0))
17750 ;
17751 return 0;
17752 }
17753 #endif //#ifndef TOLUA_DISABLE
17754
17755 /* get function: Map */
17756 #ifndef TOLUA_DISABLE_tolua_get_Map
17757 static int tolua_get_Map(lua_State* tolua_S)
17758 {
17759 tolua_pushusertype(tolua_S,(void*)&Map,"CMap");
17760 return 1;
17761 }
17762 #endif //#ifndef TOLUA_DISABLE
17763
17764 /* set function: Map */
17765 #ifndef TOLUA_DISABLE_tolua_set_Map
17766 static int tolua_set_Map(lua_State* tolua_S)
17767 {
17768 #ifndef TOLUA_RELEASE
17769 tolua_Error tolua_err;
17770 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CMap",0,&tolua_err)))
17771 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
17772 #endif
17773 Map = *((CMap*) tolua_tousertype(tolua_S,2,0))
17774 ;
17775 return 0;
17776 }
17777 #endif //#ifndef TOLUA_DISABLE
17778
17779 /* method: getGraphic of class CPatchType */
17780 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchType_getGraphic00
17781 static int tolua_stratagus_CPatchType_getGraphic00(lua_State* tolua_S)
17782 {
17783 #ifndef TOLUA_RELEASE
17784 tolua_Error tolua_err;
17785 if (
17786 !tolua_isusertype(tolua_S,1,"const CPatchType",0,&tolua_err) ||
17787 !tolua_isnoobj(tolua_S,2,&tolua_err)
17788 )
17789 goto tolua_lerror;
17790 else
17791 #endif
17792 {
17793 const CPatchType* self = (const CPatchType*) tolua_tousertype(tolua_S,1,0);
17794 #ifndef TOLUA_RELEASE
17795 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getGraphic'", NULL);
17796 #endif
17797 {
17798 const CGraphic* tolua_ret = (const CGraphic*) self->getGraphic();
17799 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CGraphic");
17800 }
17801 }
17802 return 1;
17803 #ifndef TOLUA_RELEASE
17804 tolua_lerror:
17805 tolua_error(tolua_S,"#ferror in function 'getGraphic'.",&tolua_err);
17806 return 0;
17807 #endif
17808 }
17809 #endif //#ifndef TOLUA_DISABLE
17810
17811 /* method: getTileWidth of class CPatchType */
17812 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchType_getTileWidth00
17813 static int tolua_stratagus_CPatchType_getTileWidth00(lua_State* tolua_S)
17814 {
17815 #ifndef TOLUA_RELEASE
17816 tolua_Error tolua_err;
17817 if (
17818 !tolua_isusertype(tolua_S,1,"const CPatchType",0,&tolua_err) ||
17819 !tolua_isnoobj(tolua_S,2,&tolua_err)
17820 )
17821 goto tolua_lerror;
17822 else
17823 #endif
17824 {
17825 const CPatchType* self = (const CPatchType*) tolua_tousertype(tolua_S,1,0);
17826 #ifndef TOLUA_RELEASE
17827 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTileWidth'", NULL);
17828 #endif
17829 {
17830 int tolua_ret = (int) self->getTileWidth();
17831 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
17832 }
17833 }
17834 return 1;
17835 #ifndef TOLUA_RELEASE
17836 tolua_lerror:
17837 tolua_error(tolua_S,"#ferror in function 'getTileWidth'.",&tolua_err);
17838 return 0;
17839 #endif
17840 }
17841 #endif //#ifndef TOLUA_DISABLE
17842
17843 /* method: getTileHeight of class CPatchType */
17844 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchType_getTileHeight00
17845 static int tolua_stratagus_CPatchType_getTileHeight00(lua_State* tolua_S)
17846 {
17847 #ifndef TOLUA_RELEASE
17848 tolua_Error tolua_err;
17849 if (
17850 !tolua_isusertype(tolua_S,1,"const CPatchType",0,&tolua_err) ||
17851 !tolua_isnoobj(tolua_S,2,&tolua_err)
17852 )
17853 goto tolua_lerror;
17854 else
17855 #endif
17856 {
17857 const CPatchType* self = (const CPatchType*) tolua_tousertype(tolua_S,1,0);
17858 #ifndef TOLUA_RELEASE
17859 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTileHeight'", NULL);
17860 #endif
17861 {
17862 int tolua_ret = (int) self->getTileHeight();
17863 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
17864 }
17865 }
17866 return 1;
17867 #ifndef TOLUA_RELEASE
17868 tolua_lerror:
17869 tolua_error(tolua_S,"#ferror in function 'getTileHeight'.",&tolua_err);
17870 return 0;
17871 #endif
17872 }
17873 #endif //#ifndef TOLUA_DISABLE
17874
17875 /* method: getFlag of class CPatchType */
17876 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchType_getFlag00
17877 static int tolua_stratagus_CPatchType_getFlag00(lua_State* tolua_S)
17878 {
17879 #ifndef TOLUA_RELEASE
17880 tolua_Error tolua_err;
17881 if (
17882 !tolua_isusertype(tolua_S,1,"CPatchType",0,&tolua_err) ||
17883 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
17884 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
17885 !tolua_isnoobj(tolua_S,4,&tolua_err)
17886 )
17887 goto tolua_lerror;
17888 else
17889 #endif
17890 {
17891 CPatchType* self = (CPatchType*) tolua_tousertype(tolua_S,1,0);
17892 int x = ((int) tolua_tonumber(tolua_S,2,0));
17893 int y = ((int) tolua_tonumber(tolua_S,3,0));
17894 #ifndef TOLUA_RELEASE
17895 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFlag'", NULL);
17896 #endif
17897 {
17898 unsigned short tolua_ret = (unsigned short) self->getFlag(x,y);
17899 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
17900 }
17901 }
17902 return 1;
17903 #ifndef TOLUA_RELEASE
17904 tolua_lerror:
17905 tolua_error(tolua_S,"#ferror in function 'getFlag'.",&tolua_err);
17906 return 0;
17907 #endif
17908 }
17909 #endif //#ifndef TOLUA_DISABLE
17910
17911 /* method: getType of class CPatch */
17912 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatch_getType00
17913 static int tolua_stratagus_CPatch_getType00(lua_State* tolua_S)
17914 {
17915 #ifndef TOLUA_RELEASE
17916 tolua_Error tolua_err;
17917 if (
17918 !tolua_isusertype(tolua_S,1,"CPatch",0,&tolua_err) ||
17919 !tolua_isnoobj(tolua_S,2,&tolua_err)
17920 )
17921 goto tolua_lerror;
17922 else
17923 #endif
17924 {
17925 CPatch* self = (CPatch*) tolua_tousertype(tolua_S,1,0);
17926 #ifndef TOLUA_RELEASE
17927 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getType'", NULL);
17928 #endif
17929 {
17930 CPatchType* tolua_ret = (CPatchType*) self->getType();
17931 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CPatchType");
17932 }
17933 }
17934 return 1;
17935 #ifndef TOLUA_RELEASE
17936 tolua_lerror:
17937 tolua_error(tolua_S,"#ferror in function 'getType'.",&tolua_err);
17938 return 0;
17939 #endif
17940 }
17941 #endif //#ifndef TOLUA_DISABLE
17942
17943 /* method: setPos of class CPatch */
17944 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatch_setPos00
17945 static int tolua_stratagus_CPatch_setPos00(lua_State* tolua_S)
17946 {
17947 #ifndef TOLUA_RELEASE
17948 tolua_Error tolua_err;
17949 if (
17950 !tolua_isusertype(tolua_S,1,"CPatch",0,&tolua_err) ||
17951 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
17952 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
17953 !tolua_isnoobj(tolua_S,4,&tolua_err)
17954 )
17955 goto tolua_lerror;
17956 else
17957 #endif
17958 {
17959 CPatch* self = (CPatch*) tolua_tousertype(tolua_S,1,0);
17960 int x = ((int) tolua_tonumber(tolua_S,2,0));
17961 int y = ((int) tolua_tonumber(tolua_S,3,0));
17962 #ifndef TOLUA_RELEASE
17963 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPos'", NULL);
17964 #endif
17965 {
17966 self->setPos(x,y);
17967 }
17968 }
17969 return 0;
17970 #ifndef TOLUA_RELEASE
17971 tolua_lerror:
17972 tolua_error(tolua_S,"#ferror in function 'setPos'.",&tolua_err);
17973 return 0;
17974 #endif
17975 }
17976 #endif //#ifndef TOLUA_DISABLE
17977
17978 /* method: setX of class CPatch */
17979 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatch_setX00
17980 static int tolua_stratagus_CPatch_setX00(lua_State* tolua_S)
17981 {
17982 #ifndef TOLUA_RELEASE
17983 tolua_Error tolua_err;
17984 if (
17985 !tolua_isusertype(tolua_S,1,"CPatch",0,&tolua_err) ||
17986 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
17987 !tolua_isnoobj(tolua_S,3,&tolua_err)
17988 )
17989 goto tolua_lerror;
17990 else
17991 #endif
17992 {
17993 CPatch* self = (CPatch*) tolua_tousertype(tolua_S,1,0);
17994 int x = ((int) tolua_tonumber(tolua_S,2,0));
17995 #ifndef TOLUA_RELEASE
17996 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setX'", NULL);
17997 #endif
17998 {
17999 self->setX(x);
18000 }
18001 }
18002 return 0;
18003 #ifndef TOLUA_RELEASE
18004 tolua_lerror:
18005 tolua_error(tolua_S,"#ferror in function 'setX'.",&tolua_err);
18006 return 0;
18007 #endif
18008 }
18009 #endif //#ifndef TOLUA_DISABLE
18010
18011 /* method: getX of class CPatch */
18012 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatch_getX00
18013 static int tolua_stratagus_CPatch_getX00(lua_State* tolua_S)
18014 {
18015 #ifndef TOLUA_RELEASE
18016 tolua_Error tolua_err;
18017 if (
18018 !tolua_isusertype(tolua_S,1,"const CPatch",0,&tolua_err) ||
18019 !tolua_isnoobj(tolua_S,2,&tolua_err)
18020 )
18021 goto tolua_lerror;
18022 else
18023 #endif
18024 {
18025 const CPatch* self = (const CPatch*) tolua_tousertype(tolua_S,1,0);
18026 #ifndef TOLUA_RELEASE
18027 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getX'", NULL);
18028 #endif
18029 {
18030 int tolua_ret = (int) self->getX();
18031 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
18032 }
18033 }
18034 return 1;
18035 #ifndef TOLUA_RELEASE
18036 tolua_lerror:
18037 tolua_error(tolua_S,"#ferror in function 'getX'.",&tolua_err);
18038 return 0;
18039 #endif
18040 }
18041 #endif //#ifndef TOLUA_DISABLE
18042
18043 /* method: setY of class CPatch */
18044 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatch_setY00
18045 static int tolua_stratagus_CPatch_setY00(lua_State* tolua_S)
18046 {
18047 #ifndef TOLUA_RELEASE
18048 tolua_Error tolua_err;
18049 if (
18050 !tolua_isusertype(tolua_S,1,"CPatch",0,&tolua_err) ||
18051 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
18052 !tolua_isnoobj(tolua_S,3,&tolua_err)
18053 )
18054 goto tolua_lerror;
18055 else
18056 #endif
18057 {
18058 CPatch* self = (CPatch*) tolua_tousertype(tolua_S,1,0);
18059 int y = ((int) tolua_tonumber(tolua_S,2,0));
18060 #ifndef TOLUA_RELEASE
18061 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setY'", NULL);
18062 #endif
18063 {
18064 self->setY(y);
18065 }
18066 }
18067 return 0;
18068 #ifndef TOLUA_RELEASE
18069 tolua_lerror:
18070 tolua_error(tolua_S,"#ferror in function 'setY'.",&tolua_err);
18071 return 0;
18072 #endif
18073 }
18074 #endif //#ifndef TOLUA_DISABLE
18075
18076 /* method: getY of class CPatch */
18077 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatch_getY00
18078 static int tolua_stratagus_CPatch_getY00(lua_State* tolua_S)
18079 {
18080 #ifndef TOLUA_RELEASE
18081 tolua_Error tolua_err;
18082 if (
18083 !tolua_isusertype(tolua_S,1,"const CPatch",0,&tolua_err) ||
18084 !tolua_isnoobj(tolua_S,2,&tolua_err)
18085 )
18086 goto tolua_lerror;
18087 else
18088 #endif
18089 {
18090 const CPatch* self = (const CPatch*) tolua_tousertype(tolua_S,1,0);
18091 #ifndef TOLUA_RELEASE
18092 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getY'", NULL);
18093 #endif
18094 {
18095 int tolua_ret = (int) self->getY();
18096 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
18097 }
18098 }
18099 return 1;
18100 #ifndef TOLUA_RELEASE
18101 tolua_lerror:
18102 tolua_error(tolua_S,"#ferror in function 'getY'.",&tolua_err);
18103 return 0;
18104 #endif
18105 }
18106 #endif //#ifndef TOLUA_DISABLE
18107
18108 /* method: add of class CPatchManager */
18109 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchManager_add00
18110 static int tolua_stratagus_CPatchManager_add00(lua_State* tolua_S)
18111 {
18112 #ifndef TOLUA_RELEASE
18113 tolua_Error tolua_err;
18114 if (
18115 !tolua_isusertype(tolua_S,1,"CPatchManager",0,&tolua_err) ||
18116 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
18117 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
18118 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
18119 !tolua_isnoobj(tolua_S,5,&tolua_err)
18120 )
18121 goto tolua_lerror;
18122 else
18123 #endif
18124 {
18125 CPatchManager* self = (CPatchManager*) tolua_tousertype(tolua_S,1,0);
18126 std::string typeName = ((std::string) tolua_tocppstring(tolua_S,2,0));
18127 int x = ((int) tolua_tonumber(tolua_S,3,0));
18128 int y = ((int) tolua_tonumber(tolua_S,4,0));
18129 #ifndef TOLUA_RELEASE
18130 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'", NULL);
18131 #endif
18132 {
18133 CPatch* tolua_ret = (CPatch*) self->add(typeName,x,y);
18134 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CPatch");
18135 }
18136 }
18137 return 1;
18138 #ifndef TOLUA_RELEASE
18139 tolua_lerror:
18140 tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
18141 return 0;
18142 #endif
18143 }
18144 #endif //#ifndef TOLUA_DISABLE
18145
18146 /* method: moveToTop of class CPatchManager */
18147 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchManager_moveToTop00
18148 static int tolua_stratagus_CPatchManager_moveToTop00(lua_State* tolua_S)
18149 {
18150 #ifndef TOLUA_RELEASE
18151 tolua_Error tolua_err;
18152 if (
18153 !tolua_isusertype(tolua_S,1,"CPatchManager",0,&tolua_err) ||
18154 !tolua_isusertype(tolua_S,2,"CPatch",0,&tolua_err) ||
18155 !tolua_isnoobj(tolua_S,3,&tolua_err)
18156 )
18157 goto tolua_lerror;
18158 else
18159 #endif
18160 {
18161 CPatchManager* self = (CPatchManager*) tolua_tousertype(tolua_S,1,0);
18162 CPatch* patch = ((CPatch*) tolua_tousertype(tolua_S,2,0));
18163 #ifndef TOLUA_RELEASE
18164 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveToTop'", NULL);
18165 #endif
18166 {
18167 self->moveToTop(patch);
18168 }
18169 }
18170 return 0;
18171 #ifndef TOLUA_RELEASE
18172 tolua_lerror:
18173 tolua_error(tolua_S,"#ferror in function 'moveToTop'.",&tolua_err);
18174 return 0;
18175 #endif
18176 }
18177 #endif //#ifndef TOLUA_DISABLE
18178
18179 /* method: moveToBottom of class CPatchManager */
18180 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchManager_moveToBottom00
18181 static int tolua_stratagus_CPatchManager_moveToBottom00(lua_State* tolua_S)
18182 {
18183 #ifndef TOLUA_RELEASE
18184 tolua_Error tolua_err;
18185 if (
18186 !tolua_isusertype(tolua_S,1,"CPatchManager",0,&tolua_err) ||
18187 !tolua_isusertype(tolua_S,2,"CPatch",0,&tolua_err) ||
18188 !tolua_isnoobj(tolua_S,3,&tolua_err)
18189 )
18190 goto tolua_lerror;
18191 else
18192 #endif
18193 {
18194 CPatchManager* self = (CPatchManager*) tolua_tousertype(tolua_S,1,0);
18195 CPatch* patch = ((CPatch*) tolua_tousertype(tolua_S,2,0));
18196 #ifndef TOLUA_RELEASE
18197 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveToBottom'", NULL);
18198 #endif
18199 {
18200 self->moveToBottom(patch);
18201 }
18202 }
18203 return 0;
18204 #ifndef TOLUA_RELEASE
18205 tolua_lerror:
18206 tolua_error(tolua_S,"#ferror in function 'moveToBottom'.",&tolua_err);
18207 return 0;
18208 #endif
18209 }
18210 #endif //#ifndef TOLUA_DISABLE
18211
18212 /* method: getPatch of class CPatchManager */
18213 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchManager_getPatch00
18214 static int tolua_stratagus_CPatchManager_getPatch00(lua_State* tolua_S)
18215 {
18216 #ifndef TOLUA_RELEASE
18217 tolua_Error tolua_err;
18218 if (
18219 !tolua_isusertype(tolua_S,1,"const CPatchManager",0,&tolua_err) ||
18220 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
18221 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
18222 !tolua_isnoobj(tolua_S,4,&tolua_err)
18223 )
18224 goto tolua_lerror;
18225 else
18226 #endif
18227 {
18228 const CPatchManager* self = (const CPatchManager*) tolua_tousertype(tolua_S,1,0);
18229 int x = ((int) tolua_tonumber(tolua_S,2,0));
18230 int y = ((int) tolua_tonumber(tolua_S,3,0));
18231 #ifndef TOLUA_RELEASE
18232 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPatch'", NULL);
18233 #endif
18234 {
18235 CPatch* tolua_ret = (CPatch*) self->getPatch(x,y);
18236 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CPatch");
18237 }
18238 }
18239 return 1;
18240 #ifndef TOLUA_RELEASE
18241 tolua_lerror:
18242 tolua_error(tolua_S,"#ferror in function 'getPatch'.",&tolua_err);
18243 return 0;
18244 #endif
18245 }
18246 #endif //#ifndef TOLUA_DISABLE
18247
18248 /* method: getPatchTypeNames of class CPatchManager */
18249 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchManager_getPatchTypeNames00
18250 static int tolua_stratagus_CPatchManager_getPatchTypeNames00(lua_State* tolua_S)
18251 {
18252 #ifndef TOLUA_RELEASE
18253 tolua_Error tolua_err;
18254 if (
18255 !tolua_isusertype(tolua_S,1,"const CPatchManager",0,&tolua_err) ||
18256 !tolua_isnoobj(tolua_S,2,&tolua_err)
18257 )
18258 goto tolua_lerror;
18259 else
18260 #endif
18261 {
18262 const CPatchManager* self = (const CPatchManager*) tolua_tousertype(tolua_S,1,0);
18263 #ifndef TOLUA_RELEASE
18264 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPatchTypeNames'", NULL);
18265 #endif
18266 {
18267 vector<string> tolua_ret = (vector<string>) self->getPatchTypeNames();
18268 {
18269 #ifdef __cplusplus
18270 void* tolua_obj = Mtolua_new((vector<string>)(tolua_ret));
18271 tolua_pushusertype(tolua_S,tolua_obj,"vector<string>");
18272 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
18273 #else
18274 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<string>));
18275 tolua_pushusertype(tolua_S,tolua_obj,"vector<string>");
18276 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
18277 #endif
18278 }
18279 }
18280 }
18281 return 1;
18282 #ifndef TOLUA_RELEASE
18283 tolua_lerror:
18284 tolua_error(tolua_S,"#ferror in function 'getPatchTypeNames'.",&tolua_err);
18285 return 0;
18286 #endif
18287 }
18288 #endif //#ifndef TOLUA_DISABLE
18289
18290 /* method: getPatchTypeNamesUsingGraphic of class CPatchManager */
18291 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchManager_getPatchTypeNamesUsingGraphic00
18292 static int tolua_stratagus_CPatchManager_getPatchTypeNamesUsingGraphic00(lua_State* tolua_S)
18293 {
18294 #ifndef TOLUA_RELEASE
18295 tolua_Error tolua_err;
18296 if (
18297 !tolua_isusertype(tolua_S,1,"const CPatchManager",0,&tolua_err) ||
18298 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
18299 !tolua_isnoobj(tolua_S,3,&tolua_err)
18300 )
18301 goto tolua_lerror;
18302 else
18303 #endif
18304 {
18305 const CPatchManager* self = (const CPatchManager*) tolua_tousertype(tolua_S,1,0);
18306 std::string graphicFile = ((std::string) tolua_tocppstring(tolua_S,2,0));
18307 #ifndef TOLUA_RELEASE
18308 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPatchTypeNamesUsingGraphic'", NULL);
18309 #endif
18310 {
18311 vector<string> tolua_ret = (vector<string>) self->getPatchTypeNamesUsingGraphic(graphicFile);
18312 {
18313 #ifdef __cplusplus
18314 void* tolua_obj = Mtolua_new((vector<string>)(tolua_ret));
18315 tolua_pushusertype(tolua_S,tolua_obj,"vector<string>");
18316 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
18317 #else
18318 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(vector<string>));
18319 tolua_pushusertype(tolua_S,tolua_obj,"vector<string>");
18320 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
18321 #endif
18322 }
18323 }
18324 }
18325 return 1;
18326 #ifndef TOLUA_RELEASE
18327 tolua_lerror:
18328 tolua_error(tolua_S,"#ferror in function 'getPatchTypeNamesUsingGraphic'.",&tolua_err);
18329 return 0;
18330 #endif
18331 }
18332 #endif //#ifndef TOLUA_DISABLE
18333
18334 /* method: newPatchType of class CPatchManager */
18335 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchManager_newPatchType00
18336 static int tolua_stratagus_CPatchManager_newPatchType00(lua_State* tolua_S)
18337 {
18338 #ifndef TOLUA_RELEASE
18339 tolua_Error tolua_err;
18340 if (
18341 !tolua_isusertype(tolua_S,1,"CPatchManager",0,&tolua_err) ||
18342 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
18343 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
18344 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
18345 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
18346 !tolua_istable(tolua_S,6,0,&tolua_err) ||
18347 !tolua_iscppstring(tolua_S,7,0,&tolua_err) ||
18348 !tolua_isnoobj(tolua_S,8,&tolua_err)
18349 )
18350 goto tolua_lerror;
18351 else
18352 #endif
18353 {
18354 CPatchManager* self = (CPatchManager*) tolua_tousertype(tolua_S,1,0);
18355 std::string name = ((std::string) tolua_tocppstring(tolua_S,2,0));
18356 std::string file = ((std::string) tolua_tocppstring(tolua_S,3,0));
18357 int width = ((int) tolua_tonumber(tolua_S,4,0));
18358 int height = ((int) tolua_tonumber(tolua_S,5,0));
18359 #ifdef __cplusplus
18360 int* flags = Mtolua_new_dim(int, width*height);
18361 #else
18362 int* flags = (int*) malloc((width*height)*sizeof(int));
18363 #endif
18364 std::string theme = ((std::string) tolua_tocppstring(tolua_S,7,0));
18365 #ifndef TOLUA_RELEASE
18366 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'newPatchType'", NULL);
18367 #endif
18368 {
18369 #ifndef TOLUA_RELEASE
18370 if (!tolua_isnumberarray(tolua_S,6,width*height,0,&tolua_err))
18371 goto tolua_lerror;
18372 else
18373 #endif
18374 {
18375 int i;
18376 for(i=0; i<width*height;i++)
18377 flags[i] = ((int) tolua_tofieldnumber(tolua_S,6,i+1,0));
18378 }
18379 }
18380 {
18381 CPatchType* tolua_ret = (CPatchType*) self->newPatchType(name,file,width,height,flags,theme);
18382 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CPatchType");
18383 }
18384 {
18385 int i;
18386 for(i=0; i<width*height;i++)
18387 tolua_pushfieldnumber(tolua_S,6,i+1,(lua_Number) flags[i]);
18388 }
18389 #ifdef __cplusplus
18390 Mtolua_delete_dim(flags);
18391 #else
18392 free(flags);
18393 #endif
18394 }
18395 return 1;
18396 #ifndef TOLUA_RELEASE
18397 tolua_lerror:
18398 tolua_error(tolua_S,"#ferror in function 'newPatchType'.",&tolua_err);
18399 return 0;
18400 #endif
18401 }
18402 #endif //#ifndef TOLUA_DISABLE
18403
18404 /* method: computePatchSize of class CPatchManager */
18405 #ifndef TOLUA_DISABLE_tolua_stratagus_CPatchManager_computePatchSize00
18406 static int tolua_stratagus_CPatchManager_computePatchSize00(lua_State* tolua_S)
18407 {
18408 #ifndef TOLUA_RELEASE
18409 tolua_Error tolua_err;
18410 if (
18411 !tolua_isusertype(tolua_S,1,"const CPatchManager",0,&tolua_err) ||
18412 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
18413 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
18414 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
18415 !tolua_isnoobj(tolua_S,5,&tolua_err)
18416 )
18417 goto tolua_lerror;
18418 else
18419 #endif
18420 {
18421 const CPatchManager* self = (const CPatchManager*) tolua_tousertype(tolua_S,1,0);
18422 std::string graphicFile = ((std::string) tolua_tocppstring(tolua_S,2,0));
18423 int width = ((int) tolua_tonumber(tolua_S,3,0));
18424 int height = ((int) tolua_tonumber(tolua_S,4,0));
18425 #ifndef TOLUA_RELEASE
18426 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'computePatchSize'", NULL);
18427 #endif
18428 {
18429 bool tolua_ret = (bool) self->computePatchSize(graphicFile,&width,&height);
18430 tolua_pushboolean(tolua_S,(bool)tolua_ret);
18431 tolua_pushnumber(tolua_S,(lua_Number)width);
18432 tolua_pushnumber(tolua_S,(lua_Number)height);
18433 }
18434 }
18435 return 3;
18436 #ifndef TOLUA_RELEASE
18437 tolua_lerror:
18438 tolua_error(tolua_S,"#ferror in function 'computePatchSize'.",&tolua_err);
18439 return 0;
18440 #endif
18441 }
18442 #endif //#ifndef TOLUA_DISABLE
18443
18444 /* get function: AStarFixedUnitCrossingCost */
18445 #ifndef TOLUA_DISABLE_tolua_get_AStarFixedUnitCrossingCost
18446 static int tolua_get_AStarFixedUnitCrossingCost(lua_State* tolua_S)
18447 {
18448 tolua_pushnumber(tolua_S,(lua_Number)GetAStarFixedUnitCrossingCost());
18449 return 1;
18450 }
18451 #endif //#ifndef TOLUA_DISABLE
18452
18453 /* set function: AStarFixedUnitCrossingCost */
18454 #ifndef TOLUA_DISABLE_tolua_set_AStarFixedUnitCrossingCost
18455 static int tolua_set_AStarFixedUnitCrossingCost(lua_State* tolua_S)
18456 {
18457 #ifndef TOLUA_RELEASE
18458 tolua_Error tolua_err;
18459 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
18460 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
18461 #endif
18462 SetAStarFixedUnitCrossingCost(((int) tolua_tonumber(tolua_S,2,0))
18463 )
18464 ;
18465 return 0;
18466 }
18467 #endif //#ifndef TOLUA_DISABLE
18468
18469 /* get function: AStarMovingUnitCrossingCost */
18470 #ifndef TOLUA_DISABLE_tolua_get_AStarMovingUnitCrossingCost
18471 static int tolua_get_AStarMovingUnitCrossingCost(lua_State* tolua_S)
18472 {
18473 tolua_pushnumber(tolua_S,(lua_Number)GetAStarMovingUnitCrossingCost());
18474 return 1;
18475 }
18476 #endif //#ifndef TOLUA_DISABLE
18477
18478 /* set function: AStarMovingUnitCrossingCost */
18479 #ifndef TOLUA_DISABLE_tolua_set_AStarMovingUnitCrossingCost
18480 static int tolua_set_AStarMovingUnitCrossingCost(lua_State* tolua_S)
18481 {
18482 #ifndef TOLUA_RELEASE
18483 tolua_Error tolua_err;
18484 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
18485 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
18486 #endif
18487 SetAStarMovingUnitCrossingCost(((int) tolua_tonumber(tolua_S,2,0))
18488 )
18489 ;
18490 return 0;
18491 }
18492 #endif //#ifndef TOLUA_DISABLE
18493
18494 /* get function: AStarKnowUnseenTerrain */
18495 #ifndef TOLUA_DISABLE_tolua_get_AStarKnowUnseenTerrain
18496 static int tolua_get_AStarKnowUnseenTerrain(lua_State* tolua_S)
18497 {
18498 tolua_pushboolean(tolua_S,(bool)AStarKnowUnseenTerrain);
18499 return 1;
18500 }
18501 #endif //#ifndef TOLUA_DISABLE
18502
18503 /* set function: AStarKnowUnseenTerrain */
18504 #ifndef TOLUA_DISABLE_tolua_set_AStarKnowUnseenTerrain
18505 static int tolua_set_AStarKnowUnseenTerrain(lua_State* tolua_S)
18506 {
18507 #ifndef TOLUA_RELEASE
18508 tolua_Error tolua_err;
18509 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
18510 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
18511 #endif
18512 AStarKnowUnseenTerrain = ((bool) tolua_toboolean(tolua_S,2,0))
18513 ;
18514 return 0;
18515 }
18516 #endif //#ifndef TOLUA_DISABLE
18517
18518 /* get function: AStarUnknownTerrainCost */
18519 #ifndef TOLUA_DISABLE_tolua_get_AStarUnknownTerrainCost
18520 static int tolua_get_AStarUnknownTerrainCost(lua_State* tolua_S)
18521 {
18522 tolua_pushnumber(tolua_S,(lua_Number)GetAStarUnknownTerrainCost());
18523 return 1;
18524 }
18525 #endif //#ifndef TOLUA_DISABLE
18526
18527 /* set function: AStarUnknownTerrainCost */
18528 #ifndef TOLUA_DISABLE_tolua_set_AStarUnknownTerrainCost
18529 static int tolua_set_AStarUnknownTerrainCost(lua_State* tolua_S)
18530 {
18531 #ifndef TOLUA_RELEASE
18532 tolua_Error tolua_err;
18533 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
18534 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
18535 #endif
18536 SetAStarUnknownTerrainCost(((int) tolua_tonumber(tolua_S,2,0))
18537 )
18538 ;
18539 return 0;
18540 }
18541 #endif //#ifndef TOLUA_DISABLE
18542
18543 /* function: GetNumOpponents */
18544 #ifndef TOLUA_DISABLE_tolua_stratagus_GetNumOpponents00
18545 static int tolua_stratagus_GetNumOpponents00(lua_State* tolua_S)
18546 {
18547 #ifndef TOLUA_RELEASE
18548 tolua_Error tolua_err;
18549 if (
18550 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
18551 !tolua_isnoobj(tolua_S,2,&tolua_err)
18552 )
18553 goto tolua_lerror;
18554 else
18555 #endif
18556 {
18557 int player = ((int) tolua_tonumber(tolua_S,1,0));
18558 {
18559 int tolua_ret = (int) GetNumOpponents(player);
18560 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
18561 }
18562 }
18563 return 1;
18564 #ifndef TOLUA_RELEASE
18565 tolua_lerror:
18566 tolua_error(tolua_S,"#ferror in function 'GetNumOpponents'.",&tolua_err);
18567 return 0;
18568 #endif
18569 }
18570 #endif //#ifndef TOLUA_DISABLE
18571
18572 /* function: GetTimer */
18573 #ifndef TOLUA_DISABLE_tolua_stratagus_GetTimer00
18574 static int tolua_stratagus_GetTimer00(lua_State* tolua_S)
18575 {
18576 #ifndef TOLUA_RELEASE
18577 tolua_Error tolua_err;
18578 if (
18579 !tolua_isnoobj(tolua_S,1,&tolua_err)
18580 )
18581 goto tolua_lerror;
18582 else
18583 #endif
18584 {
18585 {
18586 int tolua_ret = (int) GetTimer();
18587 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
18588 }
18589 }
18590 return 1;
18591 #ifndef TOLUA_RELEASE
18592 tolua_lerror:
18593 tolua_error(tolua_S,"#ferror in function 'GetTimer'.",&tolua_err);
18594 return 0;
18595 #endif
18596 }
18597 #endif //#ifndef TOLUA_DISABLE
18598
18599 /* function: ActionVictory */
18600 #ifndef TOLUA_DISABLE_tolua_stratagus_ActionVictory00
18601 static int tolua_stratagus_ActionVictory00(lua_State* tolua_S)
18602 {
18603 #ifndef TOLUA_RELEASE
18604 tolua_Error tolua_err;
18605 if (
18606 !tolua_isnoobj(tolua_S,1,&tolua_err)
18607 )
18608 goto tolua_lerror;
18609 else
18610 #endif
18611 {
18612 {
18613 ActionVictory();
18614 }
18615 }
18616 return 0;
18617 #ifndef TOLUA_RELEASE
18618 tolua_lerror:
18619 tolua_error(tolua_S,"#ferror in function 'ActionVictory'.",&tolua_err);
18620 return 0;
18621 #endif
18622 }
18623 #endif //#ifndef TOLUA_DISABLE
18624
18625 /* function: ActionDefeat */
18626 #ifndef TOLUA_DISABLE_tolua_stratagus_ActionDefeat00
18627 static int tolua_stratagus_ActionDefeat00(lua_State* tolua_S)
18628 {
18629 #ifndef TOLUA_RELEASE
18630 tolua_Error tolua_err;
18631 if (
18632 !tolua_isnoobj(tolua_S,1,&tolua_err)
18633 )
18634 goto tolua_lerror;
18635 else
18636 #endif
18637 {
18638 {
18639 ActionDefeat();
18640 }
18641 }
18642 return 0;
18643 #ifndef TOLUA_RELEASE
18644 tolua_lerror:
18645 tolua_error(tolua_S,"#ferror in function 'ActionDefeat'.",&tolua_err);
18646 return 0;
18647 #endif
18648 }
18649 #endif //#ifndef TOLUA_DISABLE
18650
18651 /* function: ActionDraw */
18652 #ifndef TOLUA_DISABLE_tolua_stratagus_ActionDraw00
18653 static int tolua_stratagus_ActionDraw00(lua_State* tolua_S)
18654 {
18655 #ifndef TOLUA_RELEASE
18656 tolua_Error tolua_err;
18657 if (
18658 !tolua_isnoobj(tolua_S,1,&tolua_err)
18659 )
18660 goto tolua_lerror;
18661 else
18662 #endif
18663 {
18664 {
18665 ActionDraw();
18666 }
18667 }
18668 return 0;
18669 #ifndef TOLUA_RELEASE
18670 tolua_lerror:
18671 tolua_error(tolua_S,"#ferror in function 'ActionDraw'.",&tolua_err);
18672 return 0;
18673 #endif
18674 }
18675 #endif //#ifndef TOLUA_DISABLE
18676
18677 /* function: ActionSetTimer */
18678 #ifndef TOLUA_DISABLE_tolua_stratagus_ActionSetTimer00
18679 static int tolua_stratagus_ActionSetTimer00(lua_State* tolua_S)
18680 {
18681 #ifndef TOLUA_RELEASE
18682 tolua_Error tolua_err;
18683 if (
18684 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
18685 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
18686 !tolua_isnoobj(tolua_S,3,&tolua_err)
18687 )
18688 goto tolua_lerror;
18689 else
18690 #endif
18691 {
18692 int cycles = ((int) tolua_tonumber(tolua_S,1,0));
18693 bool increasing = ((bool) tolua_toboolean(tolua_S,2,0));
18694 {
18695 ActionSetTimer(cycles,increasing);
18696 }
18697 }
18698 return 0;
18699 #ifndef TOLUA_RELEASE
18700 tolua_lerror:
18701 tolua_error(tolua_S,"#ferror in function 'ActionSetTimer'.",&tolua_err);
18702 return 0;
18703 #endif
18704 }
18705 #endif //#ifndef TOLUA_DISABLE
18706
18707 /* function: ActionStartTimer */
18708 #ifndef TOLUA_DISABLE_tolua_stratagus_ActionStartTimer00
18709 static int tolua_stratagus_ActionStartTimer00(lua_State* tolua_S)
18710 {
18711 #ifndef TOLUA_RELEASE
18712 tolua_Error tolua_err;
18713 if (
18714 !tolua_isnoobj(tolua_S,1,&tolua_err)
18715 )
18716 goto tolua_lerror;
18717 else
18718 #endif
18719 {
18720 {
18721 ActionStartTimer();
18722 }
18723 }
18724 return 0;
18725 #ifndef TOLUA_RELEASE
18726 tolua_lerror:
18727 tolua_error(tolua_S,"#ferror in function 'ActionStartTimer'.",&tolua_err);
18728 return 0;
18729 #endif
18730 }
18731 #endif //#ifndef TOLUA_DISABLE
18732
18733 /* function: ActionStopTimer */
18734 #ifndef TOLUA_DISABLE_tolua_stratagus_ActionStopTimer00
18735 static int tolua_stratagus_ActionStopTimer00(lua_State* tolua_S)
18736 {
18737 #ifndef TOLUA_RELEASE
18738 tolua_Error tolua_err;
18739 if (
18740 !tolua_isnoobj(tolua_S,1,&tolua_err)
18741 )
18742 goto tolua_lerror;
18743 else
18744 #endif
18745 {
18746 {
18747 ActionStopTimer();
18748 }
18749 }
18750 return 0;
18751 #ifndef TOLUA_RELEASE
18752 tolua_lerror:
18753 tolua_error(tolua_S,"#ferror in function 'ActionStopTimer'.",&tolua_err);
18754 return 0;
18755 #endif
18756 }
18757 #endif //#ifndef TOLUA_DISABLE
18758
18759 /* function: SetTrigger */
18760 #ifndef TOLUA_DISABLE_tolua_stratagus_SetTrigger00
18761 static int tolua_stratagus_SetTrigger00(lua_State* tolua_S)
18762 {
18763 #ifndef TOLUA_RELEASE
18764 tolua_Error tolua_err;
18765 if (
18766 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
18767 !tolua_isnoobj(tolua_S,2,&tolua_err)
18768 )
18769 goto tolua_lerror;
18770 else
18771 #endif
18772 {
18773 int trigger = ((int) tolua_tonumber(tolua_S,1,0));
18774 {
18775 SetTrigger(trigger);
18776 }
18777 }
18778 return 0;
18779 #ifndef TOLUA_RELEASE
18780 tolua_lerror:
18781 tolua_error(tolua_S,"#ferror in function 'SetTrigger'.",&tolua_err);
18782 return 0;
18783 #endif
18784 }
18785 #endif //#ifndef TOLUA_DISABLE
18786
18787 /* method: new of class CPosition */
18788 #ifndef TOLUA_DISABLE_tolua_stratagus_CPosition_new00
18789 static int tolua_stratagus_CPosition_new00(lua_State* tolua_S)
18790 {
18791 #ifndef TOLUA_RELEASE
18792 tolua_Error tolua_err;
18793 if (
18794 !tolua_isusertable(tolua_S,1,"CPosition",0,&tolua_err) ||
18795 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
18796 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
18797 !tolua_isnoobj(tolua_S,4,&tolua_err)
18798 )
18799 goto tolua_lerror;
18800 else
18801 #endif
18802 {
18803 int x = ((int) tolua_tonumber(tolua_S,2,0));
18804 int y = ((int) tolua_tonumber(tolua_S,3,0));
18805 {
18806 CPosition* tolua_ret = (CPosition*) Mtolua_new((CPosition)(x,y));
18807 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CPosition");
18808 }
18809 }
18810 return 1;
18811 #ifndef TOLUA_RELEASE
18812 tolua_lerror:
18813 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
18814 return 0;
18815 #endif
18816 }
18817 #endif //#ifndef TOLUA_DISABLE
18818
18819 /* method: new_local of class CPosition */
18820 #ifndef TOLUA_DISABLE_tolua_stratagus_CPosition_new00_local
18821 static int tolua_stratagus_CPosition_new00_local(lua_State* tolua_S)
18822 {
18823 #ifndef TOLUA_RELEASE
18824 tolua_Error tolua_err;
18825 if (
18826 !tolua_isusertable(tolua_S,1,"CPosition",0,&tolua_err) ||
18827 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
18828 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
18829 !tolua_isnoobj(tolua_S,4,&tolua_err)
18830 )
18831 goto tolua_lerror;
18832 else
18833 #endif
18834 {
18835 int x = ((int) tolua_tonumber(tolua_S,2,0));
18836 int y = ((int) tolua_tonumber(tolua_S,3,0));
18837 {
18838 CPosition* tolua_ret = (CPosition*) Mtolua_new((CPosition)(x,y));
18839 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CPosition");
18840 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
18841 }
18842 }
18843 return 1;
18844 #ifndef TOLUA_RELEASE
18845 tolua_lerror:
18846 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
18847 return 0;
18848 #endif
18849 }
18850 #endif //#ifndef TOLUA_DISABLE
18851
18852 /* get function: x of class CPosition */
18853 #ifndef TOLUA_DISABLE_tolua_get_CPosition_x
18854 static int tolua_get_CPosition_x(lua_State* tolua_S)
18855 {
18856 CPosition* self = (CPosition*) tolua_tousertype(tolua_S,1,0);
18857 #ifndef TOLUA_RELEASE
18858 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
18859 #endif
18860 tolua_pushnumber(tolua_S,(lua_Number)self->x);
18861 return 1;
18862 }
18863 #endif //#ifndef TOLUA_DISABLE
18864
18865 /* set function: x of class CPosition */
18866 #ifndef TOLUA_DISABLE_tolua_set_CPosition_x
18867 static int tolua_set_CPosition_x(lua_State* tolua_S)
18868 {
18869 CPosition* self = (CPosition*) tolua_tousertype(tolua_S,1,0);
18870 #ifndef TOLUA_RELEASE
18871 tolua_Error tolua_err;
18872 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
18873 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
18874 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
18875 #endif
18876 self->x = ((float) tolua_tonumber(tolua_S,2,0))
18877 ;
18878 return 0;
18879 }
18880 #endif //#ifndef TOLUA_DISABLE
18881
18882 /* get function: y of class CPosition */
18883 #ifndef TOLUA_DISABLE_tolua_get_CPosition_y
18884 static int tolua_get_CPosition_y(lua_State* tolua_S)
18885 {
18886 CPosition* self = (CPosition*) tolua_tousertype(tolua_S,1,0);
18887 #ifndef TOLUA_RELEASE
18888 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
18889 #endif
18890 tolua_pushnumber(tolua_S,(lua_Number)self->y);
18891 return 1;
18892 }
18893 #endif //#ifndef TOLUA_DISABLE
18894
18895 /* set function: y of class CPosition */
18896 #ifndef TOLUA_DISABLE_tolua_set_CPosition_y
18897 static int tolua_set_CPosition_y(lua_State* tolua_S)
18898 {
18899 CPosition* self = (CPosition*) tolua_tousertype(tolua_S,1,0);
18900 #ifndef TOLUA_RELEASE
18901 tolua_Error tolua_err;
18902 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
18903 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
18904 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
18905 #endif
18906 self->y = ((float) tolua_tonumber(tolua_S,2,0))
18907 ;
18908 return 0;
18909 }
18910 #endif //#ifndef TOLUA_DISABLE
18911
18912 /* method: new of class GraphicAnimation */
18913 #ifndef TOLUA_DISABLE_tolua_stratagus_GraphicAnimation_new00
18914 static int tolua_stratagus_GraphicAnimation_new00(lua_State* tolua_S)
18915 {
18916 #ifndef TOLUA_RELEASE
18917 tolua_Error tolua_err;
18918 if (
18919 !tolua_isusertable(tolua_S,1,"GraphicAnimation",0,&tolua_err) ||
18920 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
18921 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
18922 !tolua_isnoobj(tolua_S,4,&tolua_err)
18923 )
18924 goto tolua_lerror;
18925 else
18926 #endif
18927 {
18928 CGraphic* g = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
18929 int ticksPerFrame = ((int) tolua_tonumber(tolua_S,3,0));
18930 {
18931 GraphicAnimation* tolua_ret = (GraphicAnimation*) Mtolua_new((GraphicAnimation)(g,ticksPerFrame));
18932 tolua_pushusertype(tolua_S,(void*)tolua_ret,"GraphicAnimation");
18933 }
18934 }
18935 return 1;
18936 #ifndef TOLUA_RELEASE
18937 tolua_lerror:
18938 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
18939 return 0;
18940 #endif
18941 }
18942 #endif //#ifndef TOLUA_DISABLE
18943
18944 /* method: new_local of class GraphicAnimation */
18945 #ifndef TOLUA_DISABLE_tolua_stratagus_GraphicAnimation_new00_local
18946 static int tolua_stratagus_GraphicAnimation_new00_local(lua_State* tolua_S)
18947 {
18948 #ifndef TOLUA_RELEASE
18949 tolua_Error tolua_err;
18950 if (
18951 !tolua_isusertable(tolua_S,1,"GraphicAnimation",0,&tolua_err) ||
18952 !tolua_isusertype(tolua_S,2,"CGraphic",0,&tolua_err) ||
18953 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
18954 !tolua_isnoobj(tolua_S,4,&tolua_err)
18955 )
18956 goto tolua_lerror;
18957 else
18958 #endif
18959 {
18960 CGraphic* g = ((CGraphic*) tolua_tousertype(tolua_S,2,0));
18961 int ticksPerFrame = ((int) tolua_tonumber(tolua_S,3,0));
18962 {
18963 GraphicAnimation* tolua_ret = (GraphicAnimation*) Mtolua_new((GraphicAnimation)(g,ticksPerFrame));
18964 tolua_pushusertype(tolua_S,(void*)tolua_ret,"GraphicAnimation");
18965 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
18966 }
18967 }
18968 return 1;
18969 #ifndef TOLUA_RELEASE
18970 tolua_lerror:
18971 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
18972 return 0;
18973 #endif
18974 }
18975 #endif //#ifndef TOLUA_DISABLE
18976
18977 /* method: clone of class GraphicAnimation */
18978 #ifndef TOLUA_DISABLE_tolua_stratagus_GraphicAnimation_clone00
18979 static int tolua_stratagus_GraphicAnimation_clone00(lua_State* tolua_S)
18980 {
18981 #ifndef TOLUA_RELEASE
18982 tolua_Error tolua_err;
18983 if (
18984 !tolua_isusertype(tolua_S,1,"GraphicAnimation",0,&tolua_err) ||
18985 !tolua_isnoobj(tolua_S,2,&tolua_err)
18986 )
18987 goto tolua_lerror;
18988 else
18989 #endif
18990 {
18991 GraphicAnimation* self = (GraphicAnimation*) tolua_tousertype(tolua_S,1,0);
18992 #ifndef TOLUA_RELEASE
18993 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clone'", NULL);
18994 #endif
18995 {
18996 Animation* tolua_ret = (Animation*) self->clone();
18997 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Animation");
18998 }
18999 }
19000 return 1;
19001 #ifndef TOLUA_RELEASE
19002 tolua_lerror:
19003 tolua_error(tolua_S,"#ferror in function 'clone'.",&tolua_err);
19004 return 0;
19005 #endif
19006 }
19007 #endif //#ifndef TOLUA_DISABLE
19008
19009 /* method: clone of class CParticle */
19010 #ifndef TOLUA_DISABLE_tolua_stratagus_CParticle_clone00
19011 static int tolua_stratagus_CParticle_clone00(lua_State* tolua_S)
19012 {
19013 #ifndef TOLUA_RELEASE
19014 tolua_Error tolua_err;
19015 if (
19016 !tolua_isusertype(tolua_S,1,"CParticle",0,&tolua_err) ||
19017 !tolua_isnoobj(tolua_S,2,&tolua_err)
19018 )
19019 goto tolua_lerror;
19020 else
19021 #endif
19022 {
19023 CParticle* self = (CParticle*) tolua_tousertype(tolua_S,1,0);
19024 #ifndef TOLUA_RELEASE
19025 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clone'", NULL);
19026 #endif
19027 {
19028 CParticle* tolua_ret = (CParticle*) self->clone();
19029 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CParticle");
19030 }
19031 }
19032 return 1;
19033 #ifndef TOLUA_RELEASE
19034 tolua_lerror:
19035 tolua_error(tolua_S,"#ferror in function 'clone'.",&tolua_err);
19036 return 0;
19037 #endif
19038 }
19039 #endif //#ifndef TOLUA_DISABLE
19040
19041 /* method: new of class StaticParticle */
19042 #ifndef TOLUA_DISABLE_tolua_stratagus_StaticParticle_new00
19043 static int tolua_stratagus_StaticParticle_new00(lua_State* tolua_S)
19044 {
19045 #ifndef TOLUA_RELEASE
19046 tolua_Error tolua_err;
19047 if (
19048 !tolua_isusertable(tolua_S,1,"StaticParticle",0,&tolua_err) ||
19049 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CPosition",0,&tolua_err)) ||
19050 !tolua_isusertype(tolua_S,3,"Animation",0,&tolua_err) ||
19051 !tolua_isnoobj(tolua_S,4,&tolua_err)
19052 )
19053 goto tolua_lerror;
19054 else
19055 #endif
19056 {
19057 CPosition position = *((CPosition*) tolua_tousertype(tolua_S,2,0));
19058 Animation* animation = ((Animation*) tolua_tousertype(tolua_S,3,0));
19059 {
19060 StaticParticle* tolua_ret = (StaticParticle*) Mtolua_new((StaticParticle)(position,animation));
19061 tolua_pushusertype(tolua_S,(void*)tolua_ret,"StaticParticle");
19062 }
19063 }
19064 return 1;
19065 #ifndef TOLUA_RELEASE
19066 tolua_lerror:
19067 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
19068 return 0;
19069 #endif
19070 }
19071 #endif //#ifndef TOLUA_DISABLE
19072
19073 /* method: new_local of class StaticParticle */
19074 #ifndef TOLUA_DISABLE_tolua_stratagus_StaticParticle_new00_local
19075 static int tolua_stratagus_StaticParticle_new00_local(lua_State* tolua_S)
19076 {
19077 #ifndef TOLUA_RELEASE
19078 tolua_Error tolua_err;
19079 if (
19080 !tolua_isusertable(tolua_S,1,"StaticParticle",0,&tolua_err) ||
19081 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CPosition",0,&tolua_err)) ||
19082 !tolua_isusertype(tolua_S,3,"Animation",0,&tolua_err) ||
19083 !tolua_isnoobj(tolua_S,4,&tolua_err)
19084 )
19085 goto tolua_lerror;
19086 else
19087 #endif
19088 {
19089 CPosition position = *((CPosition*) tolua_tousertype(tolua_S,2,0));
19090 Animation* animation = ((Animation*) tolua_tousertype(tolua_S,3,0));
19091 {
19092 StaticParticle* tolua_ret = (StaticParticle*) Mtolua_new((StaticParticle)(position,animation));
19093 tolua_pushusertype(tolua_S,(void*)tolua_ret,"StaticParticle");
19094 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
19095 }
19096 }
19097 return 1;
19098 #ifndef TOLUA_RELEASE
19099 tolua_lerror:
19100 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
19101 return 0;
19102 #endif
19103 }
19104 #endif //#ifndef TOLUA_DISABLE
19105
19106 /* method: new of class CChunkParticle */
19107 #ifndef TOLUA_DISABLE_tolua_stratagus_CChunkParticle_new00
19108 static int tolua_stratagus_CChunkParticle_new00(lua_State* tolua_S)
19109 {
19110 #ifndef TOLUA_RELEASE
19111 tolua_Error tolua_err;
19112 if (
19113 !tolua_isusertable(tolua_S,1,"CChunkParticle",0,&tolua_err) ||
19114 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CPosition",0,&tolua_err)) ||
19115 !tolua_isusertype(tolua_S,3,"Animation",0,&tolua_err) ||
19116 !tolua_isnoobj(tolua_S,4,&tolua_err)
19117 )
19118 goto tolua_lerror;
19119 else
19120 #endif
19121 {
19122 CPosition position = *((CPosition*) tolua_tousertype(tolua_S,2,0));
19123 Animation* smokeAnimation = ((Animation*) tolua_tousertype(tolua_S,3,0));
19124 {
19125 CChunkParticle* tolua_ret = (CChunkParticle*) Mtolua_new((CChunkParticle)(position,smokeAnimation));
19126 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CChunkParticle");
19127 }
19128 }
19129 return 1;
19130 #ifndef TOLUA_RELEASE
19131 tolua_lerror:
19132 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
19133 return 0;
19134 #endif
19135 }
19136 #endif //#ifndef TOLUA_DISABLE
19137
19138 /* method: new_local of class CChunkParticle */
19139 #ifndef TOLUA_DISABLE_tolua_stratagus_CChunkParticle_new00_local
19140 static int tolua_stratagus_CChunkParticle_new00_local(lua_State* tolua_S)
19141 {
19142 #ifndef TOLUA_RELEASE
19143 tolua_Error tolua_err;
19144 if (
19145 !tolua_isusertable(tolua_S,1,"CChunkParticle",0,&tolua_err) ||
19146 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CPosition",0,&tolua_err)) ||
19147 !tolua_isusertype(tolua_S,3,"Animation",0,&tolua_err) ||
19148 !tolua_isnoobj(tolua_S,4,&tolua_err)
19149 )
19150 goto tolua_lerror;
19151 else
19152 #endif
19153 {
19154 CPosition position = *((CPosition*) tolua_tousertype(tolua_S,2,0));
19155 Animation* smokeAnimation = ((Animation*) tolua_tousertype(tolua_S,3,0));
19156 {
19157 CChunkParticle* tolua_ret = (CChunkParticle*) Mtolua_new((CChunkParticle)(position,smokeAnimation));
19158 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CChunkParticle");
19159 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
19160 }
19161 }
19162 return 1;
19163 #ifndef TOLUA_RELEASE
19164 tolua_lerror:
19165 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
19166 return 0;
19167 #endif
19168 }
19169 #endif //#ifndef TOLUA_DISABLE
19170
19171 /* method: new of class CParticleManager */
19172 #ifndef TOLUA_DISABLE_tolua_stratagus_CParticleManager_new00
19173 static int tolua_stratagus_CParticleManager_new00(lua_State* tolua_S)
19174 {
19175 #ifndef TOLUA_RELEASE
19176 tolua_Error tolua_err;
19177 if (
19178 !tolua_isusertable(tolua_S,1,"CParticleManager",0,&tolua_err) ||
19179 !tolua_isnoobj(tolua_S,2,&tolua_err)
19180 )
19181 goto tolua_lerror;
19182 else
19183 #endif
19184 {
19185 {
19186 CParticleManager* tolua_ret = (CParticleManager*) Mtolua_new((CParticleManager)());
19187 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CParticleManager");
19188 }
19189 }
19190 return 1;
19191 #ifndef TOLUA_RELEASE
19192 tolua_lerror:
19193 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
19194 return 0;
19195 #endif
19196 }
19197 #endif //#ifndef TOLUA_DISABLE
19198
19199 /* method: new_local of class CParticleManager */
19200 #ifndef TOLUA_DISABLE_tolua_stratagus_CParticleManager_new00_local
19201 static int tolua_stratagus_CParticleManager_new00_local(lua_State* tolua_S)
19202 {
19203 #ifndef TOLUA_RELEASE
19204 tolua_Error tolua_err;
19205 if (
19206 !tolua_isusertable(tolua_S,1,"CParticleManager",0,&tolua_err) ||
19207 !tolua_isnoobj(tolua_S,2,&tolua_err)
19208 )
19209 goto tolua_lerror;
19210 else
19211 #endif
19212 {
19213 {
19214 CParticleManager* tolua_ret = (CParticleManager*) Mtolua_new((CParticleManager)());
19215 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CParticleManager");
19216 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
19217 }
19218 }
19219 return 1;
19220 #ifndef TOLUA_RELEASE
19221 tolua_lerror:
19222 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
19223 return 0;
19224 #endif
19225 }
19226 #endif //#ifndef TOLUA_DISABLE
19227
19228 /* method: delete of class CParticleManager */
19229 #ifndef TOLUA_DISABLE_tolua_stratagus_CParticleManager_delete00
19230 static int tolua_stratagus_CParticleManager_delete00(lua_State* tolua_S)
19231 {
19232 #ifndef TOLUA_RELEASE
19233 tolua_Error tolua_err;
19234 if (
19235 !tolua_isusertype(tolua_S,1,"CParticleManager",0,&tolua_err) ||
19236 !tolua_isnoobj(tolua_S,2,&tolua_err)
19237 )
19238 goto tolua_lerror;
19239 else
19240 #endif
19241 {
19242 CParticleManager* self = (CParticleManager*) tolua_tousertype(tolua_S,1,0);
19243 #ifndef TOLUA_RELEASE
19244 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
19245 #endif
19246 Mtolua_delete(self);
19247 }
19248 return 0;
19249 #ifndef TOLUA_RELEASE
19250 tolua_lerror:
19251 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
19252 return 0;
19253 #endif
19254 }
19255 #endif //#ifndef TOLUA_DISABLE
19256
19257 /* method: add of class CParticleManager */
19258 #ifndef TOLUA_DISABLE_tolua_stratagus_CParticleManager_add00
19259 static int tolua_stratagus_CParticleManager_add00(lua_State* tolua_S)
19260 {
19261 #ifndef TOLUA_RELEASE
19262 tolua_Error tolua_err;
19263 if (
19264 !tolua_isusertype(tolua_S,1,"CParticleManager",0,&tolua_err) ||
19265 !tolua_isusertype(tolua_S,2,"CParticle",0,&tolua_err) ||
19266 !tolua_isnoobj(tolua_S,3,&tolua_err)
19267 )
19268 goto tolua_lerror;
19269 else
19270 #endif
19271 {
19272 CParticleManager* self = (CParticleManager*) tolua_tousertype(tolua_S,1,0);
19273 CParticle* particle = ((CParticle*) tolua_tousertype(tolua_S,2,0));
19274 #ifndef TOLUA_RELEASE
19275 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'add'", NULL);
19276 #endif
19277 {
19278 self->add(particle);
19279 }
19280 }
19281 return 0;
19282 #ifndef TOLUA_RELEASE
19283 tolua_lerror:
19284 tolua_error(tolua_S,"#ferror in function 'add'.",&tolua_err);
19285 return 0;
19286 #endif
19287 }
19288 #endif //#ifndef TOLUA_DISABLE
19289
19290 /* get function: ParticleManager */
19291 #ifndef TOLUA_DISABLE_tolua_get_ParticleManager
19292 static int tolua_get_ParticleManager(lua_State* tolua_S)
19293 {
19294 tolua_pushusertype(tolua_S,(void*)&ParticleManager,"CParticleManager");
19295 return 1;
19296 }
19297 #endif //#ifndef TOLUA_DISABLE
19298
19299 /* set function: ParticleManager */
19300 #ifndef TOLUA_DISABLE_tolua_set_ParticleManager
19301 static int tolua_set_ParticleManager(lua_State* tolua_S)
19302 {
19303 #ifndef TOLUA_RELEASE
19304 tolua_Error tolua_err;
19305 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CParticleManager",0,&tolua_err)))
19306 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
19307 #endif
19308 ParticleManager = *((CParticleManager*) tolua_tousertype(tolua_S,2,0))
19309 ;
19310 return 0;
19311 }
19312 #endif //#ifndef TOLUA_DISABLE
19313
19314 /* function: Translate */
19315 #ifndef TOLUA_DISABLE_tolua_stratagus_Translate00
19316 static int tolua_stratagus_Translate00(lua_State* tolua_S)
19317 {
19318 #ifndef TOLUA_RELEASE
19319 tolua_Error tolua_err;
19320 if (
19321 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
19322 !tolua_isnoobj(tolua_S,2,&tolua_err)
19323 )
19324 goto tolua_lerror;
19325 else
19326 #endif
19327 {
19328 const char* str = ((const char*) tolua_tostring(tolua_S,1,0));
19329 {
19330 const char* tolua_ret = (const char*) Translate(str);
19331 tolua_pushstring(tolua_S,(const char*)tolua_ret);
19332 }
19333 }
19334 return 1;
19335 #ifndef TOLUA_RELEASE
19336 tolua_lerror:
19337 tolua_error(tolua_S,"#ferror in function 'Translate'.",&tolua_err);
19338 return 0;
19339 #endif
19340 }
19341 #endif //#ifndef TOLUA_DISABLE
19342
19343 /* function: AddTranslation */
19344 #ifndef TOLUA_DISABLE_tolua_stratagus_AddTranslation00
19345 static int tolua_stratagus_AddTranslation00(lua_State* tolua_S)
19346 {
19347 #ifndef TOLUA_RELEASE
19348 tolua_Error tolua_err;
19349 if (
19350 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
19351 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
19352 !tolua_isnoobj(tolua_S,3,&tolua_err)
19353 )
19354 goto tolua_lerror;
19355 else
19356 #endif
19357 {
19358 const string str1 = ((const string) tolua_tocppstring(tolua_S,1,0));
19359 const string str2 = ((const string) tolua_tocppstring(tolua_S,2,0));
19360 {
19361 AddTranslation(str1,str2);
19362 }
19363 }
19364 return 0;
19365 #ifndef TOLUA_RELEASE
19366 tolua_lerror:
19367 tolua_error(tolua_S,"#ferror in function 'AddTranslation'.",&tolua_err);
19368 return 0;
19369 #endif
19370 }
19371 #endif //#ifndef TOLUA_DISABLE
19372
19373 /* function: LoadPO */
19374 #ifndef TOLUA_DISABLE_tolua_stratagus_LoadPO00
19375 static int tolua_stratagus_LoadPO00(lua_State* tolua_S)
19376 {
19377 #ifndef TOLUA_RELEASE
19378 tolua_Error tolua_err;
19379 if (
19380 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
19381 !tolua_isnoobj(tolua_S,2,&tolua_err)
19382 )
19383 goto tolua_lerror;
19384 else
19385 #endif
19386 {
19387 const string file = ((const string) tolua_tocppstring(tolua_S,1,0));
19388 {
19389 LoadPO(file);
19390 }
19391 }
19392 return 0;
19393 #ifndef TOLUA_RELEASE
19394 tolua_lerror:
19395 tolua_error(tolua_S,"#ferror in function 'LoadPO'.",&tolua_err);
19396 return 0;
19397 #endif
19398 }
19399 #endif //#ifndef TOLUA_DISABLE
19400
19401 /* function: SetTranslationsFiles */
19402 #ifndef TOLUA_DISABLE_tolua_stratagus_SetTranslationsFiles00
19403 static int tolua_stratagus_SetTranslationsFiles00(lua_State* tolua_S)
19404 {
19405 #ifndef TOLUA_RELEASE
19406 tolua_Error tolua_err;
19407 if (
19408 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
19409 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
19410 !tolua_isnoobj(tolua_S,3,&tolua_err)
19411 )
19412 goto tolua_lerror;
19413 else
19414 #endif
19415 {
19416 const string stratagusfile = ((const string) tolua_tocppstring(tolua_S,1,0));
19417 const string gamefile = ((const string) tolua_tocppstring(tolua_S,2,0));
19418 {
19419 SetTranslationsFiles(stratagusfile,gamefile);
19420 }
19421 }
19422 return 0;
19423 #ifndef TOLUA_RELEASE
19424 tolua_lerror:
19425 tolua_error(tolua_S,"#ferror in function 'SetTranslationsFiles'.",&tolua_err);
19426 return 0;
19427 #endif
19428 }
19429 #endif //#ifndef TOLUA_DISABLE
19430
19431 /* get function: StratagusTranslation */
19432 #ifndef TOLUA_DISABLE_tolua_get_StratagusTranslation
19433 static int tolua_get_StratagusTranslation(lua_State* tolua_S)
19434 {
19435 tolua_pushcppstring(tolua_S,(const char*)StratagusTranslation);
19436 return 1;
19437 }
19438 #endif //#ifndef TOLUA_DISABLE
19439
19440 /* set function: StratagusTranslation */
19441 #ifndef TOLUA_DISABLE_tolua_set_StratagusTranslation
19442 static int tolua_set_StratagusTranslation(lua_State* tolua_S)
19443 {
19444 #ifndef TOLUA_RELEASE
19445 tolua_Error tolua_err;
19446 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
19447 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
19448 #endif
19449 StratagusTranslation = ((std::string) tolua_tocppstring(tolua_S,2,0))
19450 ;
19451 return 0;
19452 }
19453 #endif //#ifndef TOLUA_DISABLE
19454
19455 /* get function: GameTranslation */
19456 #ifndef TOLUA_DISABLE_tolua_get_GameTranslation
19457 static int tolua_get_GameTranslation(lua_State* tolua_S)
19458 {
19459 tolua_pushcppstring(tolua_S,(const char*)GameTranslation);
19460 return 1;
19461 }
19462 #endif //#ifndef TOLUA_DISABLE
19463
19464 /* set function: GameTranslation */
19465 #ifndef TOLUA_DISABLE_tolua_set_GameTranslation
19466 static int tolua_set_GameTranslation(lua_State* tolua_S)
19467 {
19468 #ifndef TOLUA_RELEASE
19469 tolua_Error tolua_err;
19470 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
19471 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
19472 #endif
19473 GameTranslation = ((std::string) tolua_tocppstring(tolua_S,2,0))
19474 ;
19475 return 0;
19476 }
19477 #endif //#ifndef TOLUA_DISABLE
19478
19479 /* function: SaveGame */
19480 #ifndef TOLUA_DISABLE_tolua_stratagus_SaveGame00
19481 static int tolua_stratagus_SaveGame00(lua_State* tolua_S)
19482 {
19483 #ifndef TOLUA_RELEASE
19484 tolua_Error tolua_err;
19485 if (
19486 !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
19487 !tolua_isnoobj(tolua_S,2,&tolua_err)
19488 )
19489 goto tolua_lerror;
19490 else
19491 #endif
19492 {
19493 const std::string filename = ((const std::string) tolua_tocppstring(tolua_S,1,0));
19494 {
19495 SaveGame(filename);
19496 }
19497 }
19498 return 0;
19499 #ifndef TOLUA_RELEASE
19500 tolua_lerror:
19501 tolua_error(tolua_S,"#ferror in function 'SaveGame'.",&tolua_err);
19502 return 0;
19503 #endif
19504 }
19505 #endif //#ifndef TOLUA_DISABLE
19506
19507 /* function: Translate */
19508 #ifndef TOLUA_DISABLE_tolua_stratagus__00
19509 static int tolua_stratagus__00(lua_State* tolua_S)
19510 {
19511 #ifndef TOLUA_RELEASE
19512 tolua_Error tolua_err;
19513 if (
19514 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
19515 !tolua_isnoobj(tolua_S,2,&tolua_err)
19516 )
19517 goto tolua_lerror;
19518 else
19519 #endif
19520 {
19521 const char* str = ((const char*) tolua_tostring(tolua_S,1,0));
19522 {
19523 const char* tolua_ret = (const char*) Translate(str);
19524 tolua_pushstring(tolua_S,(const char*)tolua_ret);
19525 }
19526 }
19527 return 1;
19528 #ifndef TOLUA_RELEASE
19529 tolua_lerror:
19530 tolua_error(tolua_S,"#ferror in function '_'.",&tolua_err);
19531 return 0;
19532 #endif
19533 }
19534 #endif //#ifndef TOLUA_DISABLE
19535
19536 /* function: SyncRand */
19537 #ifndef TOLUA_DISABLE_tolua_stratagus_SyncRand00
19538 static int tolua_stratagus_SyncRand00(lua_State* tolua_S)
19539 {
19540 #ifndef TOLUA_RELEASE
19541 tolua_Error tolua_err;
19542 if (
19543 !tolua_isnoobj(tolua_S,1,&tolua_err)
19544 )
19545 goto tolua_lerror;
19546 else
19547 #endif
19548 {
19549 {
19550 int tolua_ret = (int) SyncRand();
19551 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
19552 }
19553 }
19554 return 1;
19555 #ifndef TOLUA_RELEASE
19556 tolua_lerror:
19557 tolua_error(tolua_S,"#ferror in function 'SyncRand'.",&tolua_err);
19558 return 0;
19559 #endif
19560 }
19561 #endif //#ifndef TOLUA_DISABLE
19562
19563 /* function: SyncRand */
19564 #ifndef TOLUA_DISABLE_tolua_stratagus_SyncRand01
19565 static int tolua_stratagus_SyncRand01(lua_State* tolua_S)
19566 {
19567 tolua_Error tolua_err;
19568 if (
19569 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
19570 !tolua_isnoobj(tolua_S,2,&tolua_err)
19571 )
19572 goto tolua_lerror;
19573 else
19574 {
19575 int max = ((int) tolua_tonumber(tolua_S,1,0));
19576 {
19577 int tolua_ret = (int) SyncRand(max);
19578 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
19579 }
19580 }
19581 return 1;
19582 tolua_lerror:
19583 return tolua_stratagus_SyncRand00(tolua_S);
19584 }
19585 #endif //#ifndef TOLUA_DISABLE
19586
19587 /* function: Exit */
19588 #ifndef TOLUA_DISABLE_tolua_stratagus_Exit00
19589 static int tolua_stratagus_Exit00(lua_State* tolua_S)
19590 {
19591 #ifndef TOLUA_RELEASE
19592 tolua_Error tolua_err;
19593 if (
19594 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
19595 !tolua_isnoobj(tolua_S,2,&tolua_err)
19596 )
19597 goto tolua_lerror;
19598 else
19599 #endif
19600 {
19601 int err = ((int) tolua_tonumber(tolua_S,1,0));
19602 {
19603 Exit(err);
19604 }
19605 }
19606 return 0;
19607 #ifndef TOLUA_RELEASE
19608 tolua_lerror:
19609 tolua_error(tolua_S,"#ferror in function 'Exit'.",&tolua_err);
19610 return 0;
19611 #endif
19612 }
19613 #endif //#ifndef TOLUA_DISABLE
19614
19615 /* get function: CliMapName */
19616 #ifndef TOLUA_DISABLE_tolua_get_CliMapName
19617 static int tolua_get_CliMapName(lua_State* tolua_S)
19618 {
19619 tolua_pushcppstring(tolua_S,(const char*)CliMapName);
19620 return 1;
19621 }
19622 #endif //#ifndef TOLUA_DISABLE
19623
19624 /* set function: CliMapName */
19625 #ifndef TOLUA_DISABLE_tolua_set_CliMapName
19626 static int tolua_set_CliMapName(lua_State* tolua_S)
19627 {
19628 #ifndef TOLUA_RELEASE
19629 tolua_Error tolua_err;
19630 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
19631 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
19632 #endif
19633 CliMapName = ((std::string) tolua_tocppstring(tolua_S,2,0))
19634 ;
19635 return 0;
19636 }
19637 #endif //#ifndef TOLUA_DISABLE
19638
19639 /* Open function */
19640 TOLUA_API int tolua_stratagus_open (lua_State* tolua_S)
19641 {
19642 tolua_open(tolua_S);
19643 tolua_reg_types(tolua_S);
19644 tolua_module(tolua_S,NULL,1);
19645 tolua_beginmodule(tolua_S,NULL);
19646
19647 { /* begin embedded lua code */
19648 int top = lua_gettop(tolua_S);
19649 static const unsigned char B[] = {
19650 10,109,116, 32, 61, 32,123, 32, 95, 95,105,110,100,101,120,
19651 32, 61, 32,102,117,110, 99,116,105,111,110, 40,116, 44, 32,
19652 107,101,121, 41, 32,114,101,116,117,114,110, 32, 67, 73, 99,
19653 111,110, 58, 71,101,116, 40,107,101,121, 41, 32,101,110,100,
19654 32,125, 10, 73, 99,111,110,115, 32, 61, 32,123,125, 10,115,
19655 101,116,109,101,116, 97,116, 97, 98,108,101, 40, 73, 99,111,
19656 110,115, 44, 32,109,116, 41, 10,109,116, 32, 61, 32,123, 32,
19657 95, 95,105,110,100,101,120, 32, 61, 32,102,117,110, 99,116,
19658 105,111,110, 40,116, 44, 32,107,101,121, 41, 32,114,101,116,
19659 117,114,110, 32, 67, 70,111,110,116, 58, 71,101,116, 40,107,
19660 101,121, 41, 32,101,110,100, 32,125, 10, 70,111,110,116,115,
19661 32, 61, 32,123,125, 10,115,101,116,109,101,116, 97,116, 97,
19662 98,108,101, 40, 70,111,110,116,115, 44, 32,109,116, 41, 10,
19663 109,116, 32, 61, 32,123, 32, 95, 95,105,110,100,101,120, 32,
19664 61, 32,102,117,110, 99,116,105,111,110, 40,116, 44, 32,107,
19665 101,121, 41, 32,114,101,116,117,114,110, 32, 67, 70,111,110,
19666 116, 67,111,108,111,114, 58, 71,101,116, 40,107,101,121, 41,
19667 32,101,110,100, 32,125, 10, 70,111,110,116, 67,111,108,111,
19668 114,115, 32, 61, 32,123,125, 10,115,101,116,109,101,116, 97,
19669 116, 97, 98,108,101, 40, 70,111,110,116, 67,111,108,111,114,
19670 115, 44, 32,109,116, 41, 10,102,117,110, 99,116,105,111,110,
19671 32, 71, 97,109,101, 83,116, 97,114,116,105,110,103, 40, 41,
19672 10,101,110,100, 45, 45,32
19673 };
19674 tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 1");
19675 lua_settop(tolua_S, top);
19676 } /* end of embedded lua code */
19677
19678 tolua_constant(tolua_S,"MaxCosts",MaxCosts);
19679 tolua_constant(tolua_S,"EnergyCost",EnergyCost);
19680 tolua_constant(tolua_S,"MagmaCost",MagmaCost);
19681 tolua_constant(tolua_S,"PlayerMax",PlayerMax);
19682 tolua_constant(tolua_S,"PlayerNumNeutral",PlayerNumNeutral);
19683 tolua_constant(tolua_S,"UnitMax",UnitMax);
19684 tolua_constant(tolua_S,"NoButton",NoButton);
19685 tolua_constant(tolua_S,"LeftButton",LeftButton);
19686 tolua_constant(tolua_S,"MiddleButton",MiddleButton);
19687 tolua_constant(tolua_S,"RightButton",RightButton);
19688 tolua_constant(tolua_S,"UpButton",UpButton);
19689 tolua_constant(tolua_S,"DownButton",DownButton);
19690 tolua_cclass(tolua_S,"CMinimap","CMinimap","",NULL);
19691 tolua_beginmodule(tolua_S,"CMinimap");
19692 tolua_variable(tolua_S,"X",tolua_get_CMinimap_X,tolua_set_CMinimap_X);
19693 tolua_variable(tolua_S,"Y",tolua_get_CMinimap_Y,tolua_set_CMinimap_Y);
19694 tolua_variable(tolua_S,"W",tolua_get_CMinimap_W,tolua_set_CMinimap_W);
19695 tolua_variable(tolua_S,"H",tolua_get_CMinimap_H,tolua_set_CMinimap_H);
19696 tolua_variable(tolua_S,"WithTerrain",tolua_get_CMinimap_WithTerrain,tolua_set_CMinimap_WithTerrain);
19697 tolua_variable(tolua_S,"ShowSelected",tolua_get_CMinimap_ShowSelected,tolua_set_CMinimap_ShowSelected);
19698 tolua_variable(tolua_S,"Transparent",tolua_get_CMinimap_Transparent,tolua_set_CMinimap_Transparent);
19699 tolua_endmodule(tolua_S);
19700 #ifdef __cplusplus
19701 tolua_cclass(tolua_S,"LuaActionListener","LuaActionListener","",tolua_collect_LuaActionListener);
19702 #else
19703 tolua_cclass(tolua_S,"LuaActionListener","LuaActionListener","",NULL);
19704 #endif
19705 tolua_beginmodule(tolua_S,"LuaActionListener");
19706 tolua_function(tolua_S,"new",tolua_stratagus_LuaActionListener_new00);
19707 tolua_function(tolua_S,"new_local",tolua_stratagus_LuaActionListener_new00_local);
19708 tolua_function(tolua_S,".call",tolua_stratagus_LuaActionListener_new00_local);
19709 tolua_endmodule(tolua_S);
19710 #ifdef __cplusplus
19711 tolua_cclass(tolua_S,"CUIButton","CUIButton","",tolua_collect_CUIButton);
19712 #else
19713 tolua_cclass(tolua_S,"CUIButton","CUIButton","",NULL);
19714 #endif
19715 tolua_beginmodule(tolua_S,"CUIButton");
19716 tolua_function(tolua_S,"new",tolua_stratagus_CUIButton_new00);
19717 tolua_function(tolua_S,"new_local",tolua_stratagus_CUIButton_new00_local);
19718 tolua_function(tolua_S,".call",tolua_stratagus_CUIButton_new00_local);
19719 tolua_function(tolua_S,"delete",tolua_stratagus_CUIButton_delete00);
19720 tolua_variable(tolua_S,"X",tolua_get_CUIButton_X,tolua_set_CUIButton_X);
19721 tolua_variable(tolua_S,"Y",tolua_get_CUIButton_Y,tolua_set_CUIButton_Y);
19722 tolua_variable(tolua_S,"Text",tolua_get_CUIButton_Text,tolua_set_CUIButton_Text);
19723 tolua_variable(tolua_S,"Style",tolua_get_CUIButton_Style_ptr,tolua_set_CUIButton_Style_ptr);
19724 tolua_variable(tolua_S,"Callback",tolua_get_CUIButton_Callback_ptr,tolua_set_CUIButton_Callback_ptr);
19725 tolua_endmodule(tolua_S);
19726
19727 { /* begin embedded lua code */
19728 int top = lua_gettop(tolua_S);
19729 static const unsigned char B[] = {
19730 10, 95,117,105, 66,117,116,116,111,110, 67, 97,108,108, 98,
19731 97, 99,107,115, 32, 61, 32,123,125, 10, 67, 85, 73, 66,117,
19732 116,116,111,110, 46, 83,101,116, 67, 97,108,108, 98, 97, 99,
19733 107, 32, 61, 32,102,117,110, 99,116,105,111,110, 40,119, 44,
19734 32,102, 41, 10,119, 46, 67, 97,108,108, 98, 97, 99,107, 32,
19735 61, 32, 76,117, 97, 65, 99,116,105,111,110, 76,105,115,116,
19736 101,110,101,114, 40,102, 41, 10,116, 97, 98,108,101, 46,105,
19737 110,115,101,114,116, 40, 95,117,105, 66,117,116,116,111,110,
19738 67, 97,108,108, 98, 97, 99,107,115, 44, 32,119, 46, 67, 97,
19739 108,108, 98, 97, 99,107, 41, 10,101,110,100, 45, 45, 45, 45,
19740 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,32
19741 };
19742 tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 2");
19743 lua_settop(tolua_S, top);
19744 } /* end of embedded lua code */
19745
19746 tolua_cclass(tolua_S,"CMapArea","CMapArea","",NULL);
19747 tolua_beginmodule(tolua_S,"CMapArea");
19748 tolua_variable(tolua_S,"X",tolua_get_CMapArea_X,tolua_set_CMapArea_X);
19749 tolua_variable(tolua_S,"Y",tolua_get_CMapArea_Y,tolua_set_CMapArea_Y);
19750 tolua_variable(tolua_S,"EndX",tolua_get_CMapArea_EndX,tolua_set_CMapArea_EndX);
19751 tolua_variable(tolua_S,"EndY",tolua_get_CMapArea_EndY,tolua_set_CMapArea_EndY);
19752 tolua_variable(tolua_S,"ScrollPaddingLeft",tolua_get_CMapArea_ScrollPaddingLeft,tolua_set_CMapArea_ScrollPaddingLeft);
19753 tolua_variable(tolua_S,"ScrollPaddingRight",tolua_get_CMapArea_ScrollPaddingRight,tolua_set_CMapArea_ScrollPaddingRight);
19754 tolua_variable(tolua_S,"ScrollPaddingTop",tolua_get_CMapArea_ScrollPaddingTop,tolua_set_CMapArea_ScrollPaddingTop);
19755 tolua_variable(tolua_S,"ScrollPaddingBottom",tolua_get_CMapArea_ScrollPaddingBottom,tolua_set_CMapArea_ScrollPaddingBottom);
19756 tolua_endmodule(tolua_S);
19757 tolua_cclass(tolua_S,"CViewport","CViewport","",NULL);
19758 tolua_beginmodule(tolua_S,"CViewport");
19759 tolua_function(tolua_S,"Viewport2MapX",tolua_stratagus_CViewport_Viewport2MapX00);
19760 tolua_function(tolua_S,"Viewport2MapY",tolua_stratagus_CViewport_Viewport2MapY00);
19761 tolua_endmodule(tolua_S);
19762 #ifdef __cplusplus
19763 tolua_cclass(tolua_S,"CFiller","CFiller","",tolua_collect_CFiller);
19764 #else
19765 tolua_cclass(tolua_S,"CFiller","CFiller","",NULL);
19766 #endif
19767 tolua_beginmodule(tolua_S,"CFiller");
19768 tolua_function(tolua_S,"new",tolua_stratagus_CFiller_new00);
19769 tolua_function(tolua_S,"new_local",tolua_stratagus_CFiller_new00_local);
19770 tolua_function(tolua_S,".call",tolua_stratagus_CFiller_new00_local);
19771 tolua_variable(tolua_S,"G",tolua_get_CFiller_G_ptr,tolua_set_CFiller_G_ptr);
19772 tolua_variable(tolua_S,"X",tolua_get_CFiller_X,tolua_set_CFiller_X);
19773 tolua_variable(tolua_S,"Y",tolua_get_CFiller_Y,tolua_set_CFiller_Y);
19774 tolua_endmodule(tolua_S);
19775 #ifdef __cplusplus
19776 tolua_cclass(tolua_S,"vector_CFiller_","vector<CFiller>","",tolua_collect_vector_CFiller_);
19777 #else
19778 tolua_cclass(tolua_S,"vector_CFiller_","vector<CFiller>","",NULL);
19779 #endif
19780 tolua_beginmodule(tolua_S,"vector_CFiller_");
19781 tolua_function(tolua_S,"new",tolua_stratagus_vector_CFiller__new00);
19782 tolua_function(tolua_S,"new_local",tolua_stratagus_vector_CFiller__new00_local);
19783 tolua_function(tolua_S,".call",tolua_stratagus_vector_CFiller__new00_local);
19784 tolua_function(tolua_S,"delete",tolua_stratagus_vector_CFiller__delete00);
19785 tolua_function(tolua_S,".geti",tolua_stratagus_vector_CFiller___geti00);
19786 tolua_function(tolua_S,".seti",tolua_stratagus_vector_CFiller___seti00);
19787 tolua_function(tolua_S,".geti",tolua_stratagus_vector_CFiller___geti01);
19788 tolua_function(tolua_S,"at",tolua_stratagus_vector_CFiller__at00);
19789 tolua_function(tolua_S,"at",tolua_stratagus_vector_CFiller__at01);
19790 tolua_function(tolua_S,"front",tolua_stratagus_vector_CFiller__front00);
19791 tolua_function(tolua_S,"front",tolua_stratagus_vector_CFiller__front01);
19792 tolua_function(tolua_S,"back",tolua_stratagus_vector_CFiller__back00);
19793 tolua_function(tolua_S,"back",tolua_stratagus_vector_CFiller__back01);
19794 tolua_function(tolua_S,"push_back",tolua_stratagus_vector_CFiller__push_back00);
19795 tolua_function(tolua_S,"pop_back",tolua_stratagus_vector_CFiller__pop_back00);
19796 tolua_function(tolua_S,"assign",tolua_stratagus_vector_CFiller__assign00);
19797 tolua_function(tolua_S,"clear",tolua_stratagus_vector_CFiller__clear00);
19798 tolua_function(tolua_S,"empty",tolua_stratagus_vector_CFiller__empty00);
19799 tolua_function(tolua_S,"size",tolua_stratagus_vector_CFiller__size00);
19800 tolua_endmodule(tolua_S);
19801 #ifdef __cplusplus
19802 tolua_cclass(tolua_S,"vector_CUIButton_","vector<CUIButton>","",tolua_collect_vector_CUIButton_);
19803 #else
19804 tolua_cclass(tolua_S,"vector_CUIButton_","vector<CUIButton>","",NULL);
19805 #endif
19806 tolua_beginmodule(tolua_S,"vector_CUIButton_");
19807 tolua_function(tolua_S,"new",tolua_stratagus_vector_CUIButton__new00);
19808 tolua_function(tolua_S,"new_local",tolua_stratagus_vector_CUIButton__new00_local);
19809 tolua_function(tolua_S,".call",tolua_stratagus_vector_CUIButton__new00_local);
19810 tolua_function(tolua_S,"delete",tolua_stratagus_vector_CUIButton__delete00);
19811 tolua_function(tolua_S,".geti",tolua_stratagus_vector_CUIButton___geti00);
19812 tolua_function(tolua_S,".seti",tolua_stratagus_vector_CUIButton___seti00);
19813 tolua_function(tolua_S,".geti",tolua_stratagus_vector_CUIButton___geti01);
19814 tolua_function(tolua_S,"at",tolua_stratagus_vector_CUIButton__at00);
19815 tolua_function(tolua_S,"at",tolua_stratagus_vector_CUIButton__at01);
19816 tolua_function(tolua_S,"front",tolua_stratagus_vector_CUIButton__front00);
19817 tolua_function(tolua_S,"front",tolua_stratagus_vector_CUIButton__front01);
19818 tolua_function(tolua_S,"back",tolua_stratagus_vector_CUIButton__back00);
19819 tolua_function(tolua_S,"back",tolua_stratagus_vector_CUIButton__back01);
19820 tolua_function(tolua_S,"push_back",tolua_stratagus_vector_CUIButton__push_back00);
19821 tolua_function(tolua_S,"pop_back",tolua_stratagus_vector_CUIButton__pop_back00);
19822 tolua_function(tolua_S,"assign",tolua_stratagus_vector_CUIButton__assign00);
19823 tolua_function(tolua_S,"clear",tolua_stratagus_vector_CUIButton__clear00);
19824 tolua_function(tolua_S,"empty",tolua_stratagus_vector_CUIButton__empty00);
19825 tolua_function(tolua_S,"size",tolua_stratagus_vector_CUIButton__size00);
19826 tolua_endmodule(tolua_S);
19827 #ifdef __cplusplus
19828 tolua_cclass(tolua_S,"vector_string_","vector<string>","",tolua_collect_vector_string_);
19829 #else
19830 tolua_cclass(tolua_S,"vector_string_","vector<string>","",NULL);
19831 #endif
19832 tolua_beginmodule(tolua_S,"vector_string_");
19833 tolua_function(tolua_S,"new",tolua_stratagus_vector_string__new00);
19834 tolua_function(tolua_S,"new_local",tolua_stratagus_vector_string__new00_local);
19835 tolua_function(tolua_S,".call",tolua_stratagus_vector_string__new00_local);
19836 tolua_function(tolua_S,"delete",tolua_stratagus_vector_string__delete00);
19837 tolua_function(tolua_S,".geti",tolua_stratagus_vector_string___geti00);
19838 tolua_function(tolua_S,".seti",tolua_stratagus_vector_string___seti00);
19839 tolua_function(tolua_S,".geti",tolua_stratagus_vector_string___geti01);
19840 tolua_function(tolua_S,"at",tolua_stratagus_vector_string__at00);
19841 tolua_function(tolua_S,"at",tolua_stratagus_vector_string__at01);
19842 tolua_function(tolua_S,"front",tolua_stratagus_vector_string__front00);
19843 tolua_function(tolua_S,"front",tolua_stratagus_vector_string__front01);
19844 tolua_function(tolua_S,"back",tolua_stratagus_vector_string__back00);
19845 tolua_function(tolua_S,"back",tolua_stratagus_vector_string__back01);
19846 tolua_function(tolua_S,"push_back",tolua_stratagus_vector_string__push_back00);
19847 tolua_function(tolua_S,"pop_back",tolua_stratagus_vector_string__pop_back00);
19848 tolua_function(tolua_S,"assign",tolua_stratagus_vector_string__assign00);
19849 tolua_function(tolua_S,"clear",tolua_stratagus_vector_string__clear00);
19850 tolua_function(tolua_S,"empty",tolua_stratagus_vector_string__empty00);
19851 tolua_function(tolua_S,"size",tolua_stratagus_vector_string__size00);
19852 tolua_endmodule(tolua_S);
19853 tolua_cclass(tolua_S,"CButtonPanel","CButtonPanel","",NULL);
19854 tolua_beginmodule(tolua_S,"CButtonPanel");
19855 tolua_variable(tolua_S,"X",tolua_get_CButtonPanel_X,tolua_set_CButtonPanel_X);
19856 tolua_variable(tolua_S,"Y",tolua_get_CButtonPanel_Y,tolua_set_CButtonPanel_Y);
19857 tolua_variable(tolua_S,"Buttons",tolua_get_CButtonPanel_Buttons,tolua_set_CButtonPanel_Buttons);
19858 tolua_variable(tolua_S,"AutoCastBorderColorRGB",tolua_get_CButtonPanel_AutoCastBorderColorRGB,tolua_set_CButtonPanel_AutoCastBorderColorRGB);
19859 tolua_variable(tolua_S,"ShowCommandKey",tolua_get_CButtonPanel_ShowCommandKey,tolua_set_CButtonPanel_ShowCommandKey);
19860 tolua_endmodule(tolua_S);
19861 tolua_cclass(tolua_S,"CPieMenu","CPieMenu","",NULL);
19862 tolua_beginmodule(tolua_S,"CPieMenu");
19863 tolua_variable(tolua_S,"G",tolua_get_CPieMenu_G_ptr,tolua_set_CPieMenu_G_ptr);
19864 tolua_variable(tolua_S,"MouseButton",tolua_get_CPieMenu_MouseButton,tolua_set_CPieMenu_MouseButton);
19865 tolua_array(tolua_S,"X",tolua_get_stratagus_CPieMenu_X,tolua_set_stratagus_CPieMenu_X);
19866 tolua_array(tolua_S,"Y",tolua_get_stratagus_CPieMenu_Y,tolua_set_stratagus_CPieMenu_Y);
19867 tolua_function(tolua_S,"SetRadius",tolua_stratagus_CPieMenu_SetRadius00);
19868 tolua_endmodule(tolua_S);
19869 #ifdef __cplusplus
19870 tolua_cclass(tolua_S,"CResourceInfo","CResourceInfo","",tolua_collect_CResourceInfo);
19871 #else
19872 tolua_cclass(tolua_S,"CResourceInfo","CResourceInfo","",NULL);
19873 #endif
19874 tolua_beginmodule(tolua_S,"CResourceInfo");
19875 tolua_variable(tolua_S,"G",tolua_get_CResourceInfo_G_ptr,tolua_set_CResourceInfo_G_ptr);
19876 tolua_variable(tolua_S,"IconFrame",tolua_get_CResourceInfo_IconFrame,tolua_set_CResourceInfo_IconFrame);
19877 tolua_variable(tolua_S,"IconX",tolua_get_CResourceInfo_IconX,tolua_set_CResourceInfo_IconX);
19878 tolua_variable(tolua_S,"IconY",tolua_get_CResourceInfo_IconY,tolua_set_CResourceInfo_IconY);
19879 tolua_variable(tolua_S,"TextX",tolua_get_CResourceInfo_TextX,tolua_set_CResourceInfo_TextX);
19880 tolua_variable(tolua_S,"TextY",tolua_get_CResourceInfo_TextY,tolua_set_CResourceInfo_TextY);
19881 tolua_endmodule(tolua_S);
19882 tolua_cclass(tolua_S,"CInfoPanel","CInfoPanel","",NULL);
19883 tolua_beginmodule(tolua_S,"CInfoPanel");
19884 tolua_variable(tolua_S,"X",tolua_get_CInfoPanel_X,tolua_set_CInfoPanel_X);
19885 tolua_variable(tolua_S,"Y",tolua_get_CInfoPanel_Y,tolua_set_CInfoPanel_Y);
19886 tolua_endmodule(tolua_S);
19887 tolua_cclass(tolua_S,"CStatusLine","CStatusLine","",NULL);
19888 tolua_beginmodule(tolua_S,"CStatusLine");
19889 tolua_function(tolua_S,"Set",tolua_stratagus_CStatusLine_Set00);
19890 tolua_function(tolua_S,"Get",tolua_stratagus_CStatusLine_Get00);
19891 tolua_function(tolua_S,"Clear",tolua_stratagus_CStatusLine_Clear00);
19892 tolua_variable(tolua_S,"Width",tolua_get_CStatusLine_Width,tolua_set_CStatusLine_Width);
19893 tolua_variable(tolua_S,"TextX",tolua_get_CStatusLine_TextX,tolua_set_CStatusLine_TextX);
19894 tolua_variable(tolua_S,"TextY",tolua_get_CStatusLine_TextY,tolua_set_CStatusLine_TextY);
19895 tolua_variable(tolua_S,"Font",tolua_get_CStatusLine_Font_ptr,tolua_set_CStatusLine_Font_ptr);
19896 tolua_endmodule(tolua_S);
19897 tolua_cclass(tolua_S,"CUITimer","CUITimer","",NULL);
19898 tolua_beginmodule(tolua_S,"CUITimer");
19899 tolua_variable(tolua_S,"X",tolua_get_CUITimer_X,tolua_set_CUITimer_X);
19900 tolua_variable(tolua_S,"Y",tolua_get_CUITimer_Y,tolua_set_CUITimer_Y);
19901 tolua_variable(tolua_S,"Font",tolua_get_CUITimer_Font_ptr,tolua_set_CUITimer_Font_ptr);
19902 tolua_endmodule(tolua_S);
19903 tolua_cclass(tolua_S,"CUserInterface","CUserInterface","",NULL);
19904 tolua_beginmodule(tolua_S,"CUserInterface");
19905 tolua_variable(tolua_S,"NormalFontColor",tolua_get_CUserInterface_NormalFontColor,tolua_set_CUserInterface_NormalFontColor);
19906 tolua_variable(tolua_S,"ReverseFontColor",tolua_get_CUserInterface_ReverseFontColor,tolua_set_CUserInterface_ReverseFontColor);
19907 tolua_variable(tolua_S,"Fillers",tolua_get_CUserInterface_Fillers,tolua_set_CUserInterface_Fillers);
19908 tolua_array(tolua_S,"Resources",tolua_get_stratagus_CUserInterface_Resources,tolua_set_stratagus_CUserInterface_Resources);
19909 tolua_variable(tolua_S,"InfoPanel",tolua_get_CUserInterface_InfoPanel,tolua_set_CUserInterface_InfoPanel);
19910 tolua_variable(tolua_S,"SingleSelectedButton",tolua_get_CUserInterface_SingleSelectedButton_ptr,tolua_set_CUserInterface_SingleSelectedButton_ptr);
19911 tolua_variable(tolua_S,"SelectedButtons",tolua_get_CUserInterface_SelectedButtons,tolua_set_CUserInterface_SelectedButtons);
19912 tolua_variable(tolua_S,"MaxSelectedFont",tolua_get_CUserInterface_MaxSelectedFont_ptr,tolua_set_CUserInterface_MaxSelectedFont_ptr);
19913 tolua_variable(tolua_S,"MaxSelectedTextX",tolua_get_CUserInterface_MaxSelectedTextX,tolua_set_CUserInterface_MaxSelectedTextX);
19914 tolua_variable(tolua_S,"MaxSelectedTextY",tolua_get_CUserInterface_MaxSelectedTextY,tolua_set_CUserInterface_MaxSelectedTextY);
19915 tolua_variable(tolua_S,"SingleTrainingButton",tolua_get_CUserInterface_SingleTrainingButton_ptr,tolua_set_CUserInterface_SingleTrainingButton_ptr);
19916 tolua_variable(tolua_S,"TrainingButtons",tolua_get_CUserInterface_TrainingButtons,tolua_set_CUserInterface_TrainingButtons);
19917 tolua_variable(tolua_S,"TransportingButtons",tolua_get_CUserInterface_TransportingButtons,tolua_set_CUserInterface_TransportingButtons);
19918 tolua_variable(tolua_S,"CompletedBarColorRGB",tolua_get_CUserInterface_CompletedBarColorRGB,tolua_set_CUserInterface_CompletedBarColorRGB);
19919 tolua_variable(tolua_S,"CompletedBarShadow",tolua_get_CUserInterface_CompletedBarShadow,tolua_set_CUserInterface_CompletedBarShadow);
19920 tolua_variable(tolua_S,"ButtonPanel",tolua_get_CUserInterface_ButtonPanel,tolua_set_CUserInterface_ButtonPanel);
19921 tolua_variable(tolua_S,"PieMenu",tolua_get_CUserInterface_PieMenu,tolua_set_CUserInterface_PieMenu);
19922 tolua_variable(tolua_S,"MouseViewport",tolua_get_CUserInterface_MouseViewport_ptr,tolua_set_CUserInterface_MouseViewport_ptr);
19923 tolua_variable(tolua_S,"MapArea",tolua_get_CUserInterface_MapArea,tolua_set_CUserInterface_MapArea);
19924 tolua_variable(tolua_S,"MessageFont",tolua_get_CUserInterface_MessageFont_ptr,tolua_set_CUserInterface_MessageFont_ptr);
19925 tolua_variable(tolua_S,"MessageScrollSpeed",tolua_get_CUserInterface_MessageScrollSpeed,tolua_set_CUserInterface_MessageScrollSpeed);
19926 tolua_variable(tolua_S,"MenuButton",tolua_get_CUserInterface_MenuButton,tolua_set_CUserInterface_MenuButton);
19927 tolua_variable(tolua_S,"NetworkMenuButton",tolua_get_CUserInterface_NetworkMenuButton,tolua_set_CUserInterface_NetworkMenuButton);
19928 tolua_variable(tolua_S,"NetworkDiplomacyButton",tolua_get_CUserInterface_NetworkDiplomacyButton,tolua_set_CUserInterface_NetworkDiplomacyButton);
19929 tolua_variable(tolua_S,"Minimap",tolua_get_CUserInterface_Minimap,tolua_set_CUserInterface_Minimap);
19930 tolua_variable(tolua_S,"StatusLine",tolua_get_CUserInterface_StatusLine,tolua_set_CUserInterface_StatusLine);
19931 tolua_variable(tolua_S,"Timer",tolua_get_CUserInterface_Timer,tolua_set_CUserInterface_Timer);
19932 tolua_endmodule(tolua_S);
19933 tolua_variable(tolua_S,"UI",tolua_get_UI,tolua_set_UI);
19934 tolua_cclass(tolua_S,"CIcon","CIcon","",NULL);
19935 tolua_beginmodule(tolua_S,"CIcon");
19936 tolua_function(tolua_S,"New",tolua_stratagus_CIcon_New00);
19937 tolua_function(tolua_S,"Get",tolua_stratagus_CIcon_Get00);
19938 tolua_variable(tolua_S,"Ident",tolua_get_CIcon_Ident,NULL);
19939 tolua_variable(tolua_S,"G",tolua_get_CIcon_G_ptr,tolua_set_CIcon_G_ptr);
19940 tolua_variable(tolua_S,"Frame",tolua_get_CIcon_Frame,tolua_set_CIcon_Frame);
19941 tolua_endmodule(tolua_S);
19942 tolua_function(tolua_S,"FindButtonStyle",tolua_stratagus_FindButtonStyle00);
19943 tolua_function(tolua_S,"GetMouseScroll",tolua_stratagus_GetMouseScroll00);
19944 tolua_function(tolua_S,"SetMouseScroll",tolua_stratagus_SetMouseScroll00);
19945 tolua_function(tolua_S,"GetKeyScroll",tolua_stratagus_GetKeyScroll00);
19946 tolua_function(tolua_S,"SetKeyScroll",tolua_stratagus_SetKeyScroll00);
19947 tolua_function(tolua_S,"GetGrabMouse",tolua_stratagus_GetGrabMouse00);
19948 tolua_function(tolua_S,"SetGrabMouse",tolua_stratagus_SetGrabMouse00);
19949 tolua_function(tolua_S,"GetLeaveStops",tolua_stratagus_GetLeaveStops00);
19950 tolua_function(tolua_S,"SetLeaveStops",tolua_stratagus_SetLeaveStops00);
19951 tolua_function(tolua_S,"SetSavedMapPosition",tolua_stratagus_SetSavedMapPosition00);
19952 tolua_function(tolua_S,"GetDoubleClickDelay",tolua_stratagus_GetDoubleClickDelay00);
19953 tolua_function(tolua_S,"SetDoubleClickDelay",tolua_stratagus_SetDoubleClickDelay00);
19954 tolua_function(tolua_S,"GetHoldClickDelay",tolua_stratagus_GetHoldClickDelay00);
19955 tolua_function(tolua_S,"SetHoldClickDelay",tolua_stratagus_SetHoldClickDelay00);
19956 tolua_variable(tolua_S,"CursorX",tolua_get_CursorX,tolua_set_CursorX);
19957 tolua_variable(tolua_S,"CursorY",tolua_get_CursorY,tolua_set_CursorY);
19958 #ifdef __cplusplus
19959 tolua_cclass(tolua_S,"Color","Color","",tolua_collect_Color);
19960 #else
19961 tolua_cclass(tolua_S,"Color","Color","",NULL);
19962 #endif
19963 tolua_beginmodule(tolua_S,"Color");
19964 tolua_function(tolua_S,"new",tolua_stratagus_Color_new00);
19965 tolua_function(tolua_S,"new_local",tolua_stratagus_Color_new00_local);
19966 tolua_function(tolua_S,".call",tolua_stratagus_Color_new00_local);
19967 tolua_variable(tolua_S,"r",tolua_get_Color_r,tolua_set_Color_r);
19968 tolua_variable(tolua_S,"g",tolua_get_Color_g,tolua_set_Color_g);
19969 tolua_variable(tolua_S,"b",tolua_get_Color_b,tolua_set_Color_b);
19970 tolua_variable(tolua_S,"a",tolua_get_Color_a,tolua_set_Color_a);
19971 tolua_endmodule(tolua_S);
19972 tolua_cclass(tolua_S,"Graphics","Graphics","",NULL);
19973 tolua_beginmodule(tolua_S,"Graphics");
19974 tolua_constant(tolua_S,"LEFT",Graphics::LEFT);
19975 tolua_constant(tolua_S,"CENTER",Graphics::CENTER);
19976 tolua_constant(tolua_S,"RIGHT",Graphics::RIGHT);
19977 tolua_endmodule(tolua_S);
19978 tolua_cclass(tolua_S,"Widget","Widget","",NULL);
19979 tolua_beginmodule(tolua_S,"Widget");
19980 tolua_function(tolua_S,"setWidth",tolua_stratagus_Widget_setWidth00);
19981 tolua_function(tolua_S,"getWidth",tolua_stratagus_Widget_getWidth00);
19982 tolua_function(tolua_S,"setHeight",tolua_stratagus_Widget_setHeight00);
19983 tolua_function(tolua_S,"getHeight",tolua_stratagus_Widget_getHeight00);
19984 tolua_function(tolua_S,"setSize",tolua_stratagus_Widget_setSize00);
19985 tolua_function(tolua_S,"setX",tolua_stratagus_Widget_setX00);
19986 tolua_function(tolua_S,"getX",tolua_stratagus_Widget_getX00);
19987 tolua_function(tolua_S,"setY",tolua_stratagus_Widget_setY00);
19988 tolua_function(tolua_S,"getY",tolua_stratagus_Widget_getY00);
19989 tolua_function(tolua_S,"setPosition",tolua_stratagus_Widget_setPosition00);
19990 tolua_function(tolua_S,"setBorderSize",tolua_stratagus_Widget_setBorderSize00);
19991 tolua_function(tolua_S,"getBorderSize",tolua_stratagus_Widget_getBorderSize00);
19992 tolua_function(tolua_S,"setEnabled",tolua_stratagus_Widget_setEnabled00);
19993 tolua_function(tolua_S,"isEnabled",tolua_stratagus_Widget_isEnabled00);
19994 tolua_function(tolua_S,"setVisible",tolua_stratagus_Widget_setVisible00);
19995 tolua_function(tolua_S,"isVisible",tolua_stratagus_Widget_isVisible00);
19996 tolua_function(tolua_S,"setBaseColor",tolua_stratagus_Widget_setBaseColor00);
19997 tolua_function(tolua_S,"getBaseColor",tolua_stratagus_Widget_getBaseColor00);
19998 tolua_function(tolua_S,"setForegroundColor",tolua_stratagus_Widget_setForegroundColor00);
19999 tolua_function(tolua_S,"getForegroundColor",tolua_stratagus_Widget_getForegroundColor00);
20000 tolua_function(tolua_S,"setBackgroundColor",tolua_stratagus_Widget_setBackgroundColor00);
20001 tolua_function(tolua_S,"getBackgroundColor",tolua_stratagus_Widget_getBackgroundColor00);
20002 tolua_function(tolua_S,"setDisabledColor",tolua_stratagus_Widget_setDisabledColor00);
20003 tolua_function(tolua_S,"getDisabledColor",tolua_stratagus_Widget_getDisabledColor00);
20004 tolua_function(tolua_S,"setGlobalFont",tolua_stratagus_Widget_setGlobalFont00);
20005 tolua_function(tolua_S,"setFont",tolua_stratagus_Widget_setFont00);
20006 tolua_function(tolua_S,"getHotKey",tolua_stratagus_Widget_getHotKey00);
20007 tolua_function(tolua_S,"setHotKey",tolua_stratagus_Widget_setHotKey00);
20008 tolua_function(tolua_S,"setHotKey",tolua_stratagus_Widget_setHotKey01);
20009 tolua_function(tolua_S,"addActionListener",tolua_stratagus_Widget_addActionListener00);
20010 tolua_function(tolua_S,"requestFocus",tolua_stratagus_Widget_requestFocus00);
20011 tolua_endmodule(tolua_S);
20012
20013 { /* begin embedded lua code */
20014 int top = lua_gettop(tolua_S);
20015 static const unsigned char B[] = {
20016 10, 87,105,100,103,101,116, 46,115,101,116, 65, 99,116,105,
20017 111,110, 67, 97,108,108, 98, 97, 99,107, 32, 61, 32,102,117,
20018 110, 99,116,105,111,110, 40,119, 44, 32,102, 41, 10,119, 46,
20019 95, 97, 99,116,105,111,110, 99, 98, 32, 61, 32, 76,117, 97,
20020 65, 99,116,105,111,110, 76,105,115,116,101,110,101,114, 40,
20021 102, 41, 10,119, 58, 97,100,100, 65, 99,116,105,111,110, 76,
20022 105,115,116,101,110,101,114, 40,119, 46, 95, 97, 99,116,105,
20023 111,110, 99, 98, 41, 10,101,110,100, 45, 45, 45, 45, 45, 45,
20024 45, 45, 45, 45, 45, 45, 45, 45,32
20025 };
20026 tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 3");
20027 lua_settop(tolua_S, top);
20028 } /* end of embedded lua code */
20029
20030 tolua_cclass(tolua_S,"BasicContainer","BasicContainer","Widget",NULL);
20031 tolua_beginmodule(tolua_S,"BasicContainer");
20032 tolua_endmodule(tolua_S);
20033 #ifdef __cplusplus
20034 tolua_cclass(tolua_S,"ScrollArea","ScrollArea","BasicContainer",tolua_collect_ScrollArea);
20035 #else
20036 tolua_cclass(tolua_S,"ScrollArea","ScrollArea","BasicContainer",NULL);
20037 #endif
20038 tolua_beginmodule(tolua_S,"ScrollArea");
20039 tolua_function(tolua_S,"new",tolua_stratagus_ScrollArea_new00);
20040 tolua_function(tolua_S,"new_local",tolua_stratagus_ScrollArea_new00_local);
20041 tolua_function(tolua_S,".call",tolua_stratagus_ScrollArea_new00_local);
20042 tolua_function(tolua_S,"setContent",tolua_stratagus_ScrollArea_setContent00);
20043 tolua_function(tolua_S,"getContent",tolua_stratagus_ScrollArea_getContent00);
20044 tolua_function(tolua_S,"setScrollbarWidth",tolua_stratagus_ScrollArea_setScrollbarWidth00);
20045 tolua_function(tolua_S,"getScrollbarWidth",tolua_stratagus_ScrollArea_getScrollbarWidth00);
20046 tolua_endmodule(tolua_S);
20047 #ifdef __cplusplus
20048 tolua_cclass(tolua_S,"ImageWidget","ImageWidget","Widget",tolua_collect_ImageWidget);
20049 #else
20050 tolua_cclass(tolua_S,"ImageWidget","ImageWidget","Widget",NULL);
20051 #endif
20052 tolua_beginmodule(tolua_S,"ImageWidget");
20053 tolua_function(tolua_S,"new",tolua_stratagus_ImageWidget_new00);
20054 tolua_function(tolua_S,"new_local",tolua_stratagus_ImageWidget_new00_local);
20055 tolua_function(tolua_S,".call",tolua_stratagus_ImageWidget_new00_local);
20056 tolua_endmodule(tolua_S);
20057 tolua_cclass(tolua_S,"Button","Button","Widget",NULL);
20058 tolua_beginmodule(tolua_S,"Button");
20059 tolua_endmodule(tolua_S);
20060 #ifdef __cplusplus
20061 tolua_cclass(tolua_S,"ButtonWidget","ButtonWidget","Button",tolua_collect_ButtonWidget);
20062 #else
20063 tolua_cclass(tolua_S,"ButtonWidget","ButtonWidget","Button",NULL);
20064 #endif
20065 tolua_beginmodule(tolua_S,"ButtonWidget");
20066 tolua_function(tolua_S,"new",tolua_stratagus_ButtonWidget_new00);
20067 tolua_function(tolua_S,"new_local",tolua_stratagus_ButtonWidget_new00_local);
20068 tolua_function(tolua_S,".call",tolua_stratagus_ButtonWidget_new00_local);
20069 tolua_function(tolua_S,"setCaption",tolua_stratagus_ButtonWidget_setCaption00);
20070 tolua_function(tolua_S,"getCaption",tolua_stratagus_ButtonWidget_getCaption00);
20071 tolua_function(tolua_S,"adjustSize",tolua_stratagus_ButtonWidget_adjustSize00);
20072 tolua_endmodule(tolua_S);
20073 #ifdef __cplusplus
20074 tolua_cclass(tolua_S,"ImageButton","ImageButton","Button",tolua_collect_ImageButton);
20075 #else
20076 tolua_cclass(tolua_S,"ImageButton","ImageButton","Button",NULL);
20077 #endif
20078 tolua_beginmodule(tolua_S,"ImageButton");
20079 tolua_function(tolua_S,"new",tolua_stratagus_ImageButton_new00);
20080 tolua_function(tolua_S,"new_local",tolua_stratagus_ImageButton_new00_local);
20081 tolua_function(tolua_S,".call",tolua_stratagus_ImageButton_new00_local);
20082 tolua_function(tolua_S,"new",tolua_stratagus_ImageButton_new01);
20083 tolua_function(tolua_S,"new_local",tolua_stratagus_ImageButton_new01_local);
20084 tolua_function(tolua_S,".call",tolua_stratagus_ImageButton_new01_local);
20085 tolua_function(tolua_S,"setNormalImage",tolua_stratagus_ImageButton_setNormalImage00);
20086 tolua_function(tolua_S,"setPressedImage",tolua_stratagus_ImageButton_setPressedImage00);
20087 tolua_function(tolua_S,"setDisabledImage",tolua_stratagus_ImageButton_setDisabledImage00);
20088 tolua_endmodule(tolua_S);
20089 #ifdef __cplusplus
20090 tolua_cclass(tolua_S,"RadioButton","RadioButton","Widget",tolua_collect_RadioButton);
20091 #else
20092 tolua_cclass(tolua_S,"RadioButton","RadioButton","Widget",NULL);
20093 #endif
20094 tolua_beginmodule(tolua_S,"RadioButton");
20095 tolua_function(tolua_S,"new",tolua_stratagus_RadioButton_new00);
20096 tolua_function(tolua_S,"new_local",tolua_stratagus_RadioButton_new00_local);
20097 tolua_function(tolua_S,".call",tolua_stratagus_RadioButton_new00_local);
20098 tolua_function(tolua_S,"new",tolua_stratagus_RadioButton_new01);
20099 tolua_function(tolua_S,"new_local",tolua_stratagus_RadioButton_new01_local);
20100 tolua_function(tolua_S,".call",tolua_stratagus_RadioButton_new01_local);
20101 tolua_function(tolua_S,"isMarked",tolua_stratagus_RadioButton_isMarked00);
20102 tolua_function(tolua_S,"setMarked",tolua_stratagus_RadioButton_setMarked00);
20103 tolua_function(tolua_S,"getCaption",tolua_stratagus_RadioButton_getCaption00);
20104 tolua_function(tolua_S,"setCaption",tolua_stratagus_RadioButton_setCaption00);
20105 tolua_function(tolua_S,"setGroup",tolua_stratagus_RadioButton_setGroup00);
20106 tolua_function(tolua_S,"getGroup",tolua_stratagus_RadioButton_getGroup00);
20107 tolua_function(tolua_S,"adjustSize",tolua_stratagus_RadioButton_adjustSize00);
20108 tolua_endmodule(tolua_S);
20109 #ifdef __cplusplus
20110 tolua_cclass(tolua_S,"ImageRadioButton","ImageRadioButton","RadioButton",tolua_collect_ImageRadioButton);
20111 #else
20112 tolua_cclass(tolua_S,"ImageRadioButton","ImageRadioButton","RadioButton",NULL);
20113 #endif
20114 tolua_beginmodule(tolua_S,"ImageRadioButton");
20115 tolua_function(tolua_S,"new",tolua_stratagus_ImageRadioButton_new00);
20116 tolua_function(tolua_S,"new_local",tolua_stratagus_ImageRadioButton_new00_local);
20117 tolua_function(tolua_S,".call",tolua_stratagus_ImageRadioButton_new00_local);
20118 tolua_function(tolua_S,"new",tolua_stratagus_ImageRadioButton_new01);
20119 tolua_function(tolua_S,"new_local",tolua_stratagus_ImageRadioButton_new01_local);
20120 tolua_function(tolua_S,".call",tolua_stratagus_ImageRadioButton_new01_local);
20121 tolua_function(tolua_S,"setUncheckedNormalImage",tolua_stratagus_ImageRadioButton_setUncheckedNormalImage00);
20122 tolua_function(tolua_S,"setUncheckedPressedImage",tolua_stratagus_ImageRadioButton_setUncheckedPressedImage00);
20123 tolua_function(tolua_S,"setCheckedNormalImage",tolua_stratagus_ImageRadioButton_setCheckedNormalImage00);
20124 tolua_function(tolua_S,"setCheckedPressedImage",tolua_stratagus_ImageRadioButton_setCheckedPressedImage00);
20125 tolua_endmodule(tolua_S);
20126 #ifdef __cplusplus
20127 tolua_cclass(tolua_S,"CheckBox","CheckBox","Widget",tolua_collect_CheckBox);
20128 #else
20129 tolua_cclass(tolua_S,"CheckBox","CheckBox","Widget",NULL);
20130 #endif
20131 tolua_beginmodule(tolua_S,"CheckBox");
20132 tolua_function(tolua_S,"new",tolua_stratagus_CheckBox_new00);
20133 tolua_function(tolua_S,"new_local",tolua_stratagus_CheckBox_new00_local);
20134 tolua_function(tolua_S,".call",tolua_stratagus_CheckBox_new00_local);
20135 tolua_function(tolua_S,"new",tolua_stratagus_CheckBox_new01);
20136 tolua_function(tolua_S,"new_local",tolua_stratagus_CheckBox_new01_local);
20137 tolua_function(tolua_S,".call",tolua_stratagus_CheckBox_new01_local);
20138 tolua_function(tolua_S,"isMarked",tolua_stratagus_CheckBox_isMarked00);
20139 tolua_function(tolua_S,"setMarked",tolua_stratagus_CheckBox_setMarked00);
20140 tolua_function(tolua_S,"getCaption",tolua_stratagus_CheckBox_getCaption00);
20141 tolua_function(tolua_S,"setCaption",tolua_stratagus_CheckBox_setCaption00);
20142 tolua_function(tolua_S,"adjustSize",tolua_stratagus_CheckBox_adjustSize00);
20143 tolua_endmodule(tolua_S);
20144 #ifdef __cplusplus
20145 tolua_cclass(tolua_S,"ImageCheckBox","ImageCheckBox","CheckBox",tolua_collect_ImageCheckBox);
20146 #else
20147 tolua_cclass(tolua_S,"ImageCheckBox","ImageCheckBox","CheckBox",NULL);
20148 #endif
20149 tolua_beginmodule(tolua_S,"ImageCheckBox");
20150 tolua_function(tolua_S,"new",tolua_stratagus_ImageCheckBox_new00);
20151 tolua_function(tolua_S,"new_local",tolua_stratagus_ImageCheckBox_new00_local);
20152 tolua_function(tolua_S,".call",tolua_stratagus_ImageCheckBox_new00_local);
20153 tolua_function(tolua_S,"new",tolua_stratagus_ImageCheckBox_new01);
20154 tolua_function(tolua_S,"new_local",tolua_stratagus_ImageCheckBox_new01_local);
20155 tolua_function(tolua_S,".call",tolua_stratagus_ImageCheckBox_new01_local);
20156 tolua_function(tolua_S,"setUncheckedNormalImage",tolua_stratagus_ImageCheckBox_setUncheckedNormalImage00);
20157 tolua_function(tolua_S,"setUncheckedPressedImage",tolua_stratagus_ImageCheckBox_setUncheckedPressedImage00);
20158 tolua_function(tolua_S,"setCheckedNormalImage",tolua_stratagus_ImageCheckBox_setCheckedNormalImage00);
20159 tolua_function(tolua_S,"setCheckedPressedImage",tolua_stratagus_ImageCheckBox_setCheckedPressedImage00);
20160 tolua_endmodule(tolua_S);
20161 #ifdef __cplusplus
20162 tolua_cclass(tolua_S,"Slider","Slider","Widget",tolua_collect_Slider);
20163 #else
20164 tolua_cclass(tolua_S,"Slider","Slider","Widget",NULL);
20165 #endif
20166 tolua_beginmodule(tolua_S,"Slider");
20167 tolua_function(tolua_S,"new",tolua_stratagus_Slider_new00);
20168 tolua_function(tolua_S,"new_local",tolua_stratagus_Slider_new00_local);
20169 tolua_function(tolua_S,".call",tolua_stratagus_Slider_new00_local);
20170 tolua_function(tolua_S,"new",tolua_stratagus_Slider_new01);
20171 tolua_function(tolua_S,"new_local",tolua_stratagus_Slider_new01_local);
20172 tolua_function(tolua_S,".call",tolua_stratagus_Slider_new01_local);
20173 tolua_function(tolua_S,"setScale",tolua_stratagus_Slider_setScale00);
20174 tolua_function(tolua_S,"getScaleStart",tolua_stratagus_Slider_getScaleStart00);
20175 tolua_function(tolua_S,"setScaleStart",tolua_stratagus_Slider_setScaleStart00);
20176 tolua_function(tolua_S,"getScaleEnd",tolua_stratagus_Slider_getScaleEnd00);
20177 tolua_function(tolua_S,"setScaleEnd",tolua_stratagus_Slider_setScaleEnd00);
20178 tolua_function(tolua_S,"getValue",tolua_stratagus_Slider_getValue00);
20179 tolua_function(tolua_S,"setValue",tolua_stratagus_Slider_setValue00);
20180 tolua_function(tolua_S,"setMarkerLength",tolua_stratagus_Slider_setMarkerLength00);
20181 tolua_function(tolua_S,"getMarkerLength",tolua_stratagus_Slider_getMarkerLength00);
20182 tolua_function(tolua_S,"setOrientation",tolua_stratagus_Slider_setOrientation00);
20183 tolua_function(tolua_S,"getOrientation",tolua_stratagus_Slider_getOrientation00);
20184 tolua_function(tolua_S,"setStepLength",tolua_stratagus_Slider_setStepLength00);
20185 tolua_function(tolua_S,"getStepLength",tolua_stratagus_Slider_getStepLength00);
20186 tolua_constant(tolua_S,"HORIZONTAL",Slider::HORIZONTAL);
20187 tolua_constant(tolua_S,"VERTICAL",Slider::VERTICAL);
20188 tolua_endmodule(tolua_S);
20189 #ifdef __cplusplus
20190 tolua_cclass(tolua_S,"ImageSlider","ImageSlider","Slider",tolua_collect_ImageSlider);
20191 #else
20192 tolua_cclass(tolua_S,"ImageSlider","ImageSlider","Slider",NULL);
20193 #endif
20194 tolua_beginmodule(tolua_S,"ImageSlider");
20195 tolua_function(tolua_S,"new",tolua_stratagus_ImageSlider_new00);
20196 tolua_function(tolua_S,"new_local",tolua_stratagus_ImageSlider_new00_local);
20197 tolua_function(tolua_S,".call",tolua_stratagus_ImageSlider_new00_local);
20198 tolua_function(tolua_S,"new",tolua_stratagus_ImageSlider_new01);
20199 tolua_function(tolua_S,"new_local",tolua_stratagus_ImageSlider_new01_local);
20200 tolua_function(tolua_S,".call",tolua_stratagus_ImageSlider_new01_local);
20201 tolua_function(tolua_S,"setMarkerImage",tolua_stratagus_ImageSlider_setMarkerImage00);
20202 tolua_function(tolua_S,"setBackgroundImage",tolua_stratagus_ImageSlider_setBackgroundImage00);
20203 tolua_endmodule(tolua_S);
20204 #ifdef __cplusplus
20205 tolua_cclass(tolua_S,"Label","Label","Widget",tolua_collect_Label);
20206 #else
20207 tolua_cclass(tolua_S,"Label","Label","Widget",NULL);
20208 #endif
20209 tolua_beginmodule(tolua_S,"Label");
20210 tolua_function(tolua_S,"new",tolua_stratagus_Label_new00);
20211 tolua_function(tolua_S,"new_local",tolua_stratagus_Label_new00_local);
20212 tolua_function(tolua_S,".call",tolua_stratagus_Label_new00_local);
20213 tolua_function(tolua_S,"getCaption",tolua_stratagus_Label_getCaption00);
20214 tolua_function(tolua_S,"setCaption",tolua_stratagus_Label_setCaption00);
20215 tolua_function(tolua_S,"setAlignment",tolua_stratagus_Label_setAlignment00);
20216 tolua_function(tolua_S,"getAlignment",tolua_stratagus_Label_getAlignment00);
20217 tolua_function(tolua_S,"adjustSize",tolua_stratagus_Label_adjustSize00);
20218 tolua_endmodule(tolua_S);
20219 #ifdef __cplusplus
20220 tolua_cclass(tolua_S,"MultiLineLabel","MultiLineLabel","Widget",tolua_collect_MultiLineLabel);
20221 #else
20222 tolua_cclass(tolua_S,"MultiLineLabel","MultiLineLabel","Widget",NULL);
20223 #endif
20224 tolua_beginmodule(tolua_S,"MultiLineLabel");
20225 tolua_function(tolua_S,"new",tolua_stratagus_MultiLineLabel_new00);
20226 tolua_function(tolua_S,"new_local",tolua_stratagus_MultiLineLabel_new00_local);
20227 tolua_function(tolua_S,".call",tolua_stratagus_MultiLineLabel_new00_local);
20228 tolua_function(tolua_S,"new",tolua_stratagus_MultiLineLabel_new01);
20229 tolua_function(tolua_S,"new_local",tolua_stratagus_MultiLineLabel_new01_local);
20230 tolua_function(tolua_S,".call",tolua_stratagus_MultiLineLabel_new01_local);
20231 tolua_function(tolua_S,"setCaption",tolua_stratagus_MultiLineLabel_setCaption00);
20232 tolua_function(tolua_S,"getCaption",tolua_stratagus_MultiLineLabel_getCaption00);
20233 tolua_function(tolua_S,"setAlignment",tolua_stratagus_MultiLineLabel_setAlignment00);
20234 tolua_function(tolua_S,"getAlignment",tolua_stratagus_MultiLineLabel_getAlignment00);
20235 tolua_function(tolua_S,"setVerticalAlignment",tolua_stratagus_MultiLineLabel_setVerticalAlignment00);
20236 tolua_function(tolua_S,"getVerticalAlignment",tolua_stratagus_MultiLineLabel_getVerticalAlignment00);
20237 tolua_function(tolua_S,"setLineWidth",tolua_stratagus_MultiLineLabel_setLineWidth00);
20238 tolua_function(tolua_S,"getLineWidth",tolua_stratagus_MultiLineLabel_getLineWidth00);
20239 tolua_function(tolua_S,"adjustSize",tolua_stratagus_MultiLineLabel_adjustSize00);
20240 tolua_function(tolua_S,"draw",tolua_stratagus_MultiLineLabel_draw00);
20241 tolua_constant(tolua_S,"LEFT",MultiLineLabel::LEFT);
20242 tolua_constant(tolua_S,"CENTER",MultiLineLabel::CENTER);
20243 tolua_constant(tolua_S,"RIGHT",MultiLineLabel::RIGHT);
20244 tolua_constant(tolua_S,"TOP",MultiLineLabel::TOP);
20245 tolua_constant(tolua_S,"BOTTOM",MultiLineLabel::BOTTOM);
20246 tolua_endmodule(tolua_S);
20247 #ifdef __cplusplus
20248 tolua_cclass(tolua_S,"TextField","TextField","Widget",tolua_collect_TextField);
20249 #else
20250 tolua_cclass(tolua_S,"TextField","TextField","Widget",NULL);
20251 #endif
20252 tolua_beginmodule(tolua_S,"TextField");
20253 tolua_function(tolua_S,"new",tolua_stratagus_TextField_new00);
20254 tolua_function(tolua_S,"new_local",tolua_stratagus_TextField_new00_local);
20255 tolua_function(tolua_S,".call",tolua_stratagus_TextField_new00_local);
20256 tolua_function(tolua_S,"setText",tolua_stratagus_TextField_setText00);
20257 tolua_function(tolua_S,"getText",tolua_stratagus_TextField_getText00);
20258 tolua_function(tolua_S,"setMaxLengthBytes",tolua_stratagus_TextField_setMaxLengthBytes00);
20259 tolua_function(tolua_S,"getMaxLengthBytes",tolua_stratagus_TextField_getMaxLengthBytes00);
20260 tolua_endmodule(tolua_S);
20261 tolua_cclass(tolua_S,"ListBox","ListBox","Widget",NULL);
20262 tolua_beginmodule(tolua_S,"ListBox");
20263 tolua_endmodule(tolua_S);
20264 #ifdef __cplusplus
20265 tolua_cclass(tolua_S,"ListBoxWidget","ListBoxWidget","ScrollArea",tolua_collect_ListBoxWidget);
20266 #else
20267 tolua_cclass(tolua_S,"ListBoxWidget","ListBoxWidget","ScrollArea",NULL);
20268 #endif
20269 tolua_beginmodule(tolua_S,"ListBoxWidget");
20270 tolua_function(tolua_S,"new",tolua_stratagus_ListBoxWidget_new00);
20271 tolua_function(tolua_S,"new_local",tolua_stratagus_ListBoxWidget_new00_local);
20272 tolua_function(tolua_S,".call",tolua_stratagus_ListBoxWidget_new00_local);
20273 tolua_function(tolua_S,"setList",tolua_stratagus_ListBoxWidget_setList00);
20274 tolua_function(tolua_S,"setSelected",tolua_stratagus_ListBoxWidget_setSelected00);
20275 tolua_function(tolua_S,"getSelected",tolua_stratagus_ListBoxWidget_getSelected00);
20276 tolua_endmodule(tolua_S);
20277 #ifdef __cplusplus
20278 tolua_cclass(tolua_S,"Window","Window","BasicContainer",tolua_collect_Window);
20279 #else
20280 tolua_cclass(tolua_S,"Window","Window","BasicContainer",NULL);
20281 #endif
20282 tolua_beginmodule(tolua_S,"Window");
20283 tolua_function(tolua_S,"new",tolua_stratagus_Window_new00);
20284 tolua_function(tolua_S,"new_local",tolua_stratagus_Window_new00_local);
20285 tolua_function(tolua_S,".call",tolua_stratagus_Window_new00_local);
20286 tolua_function(tolua_S,"new",tolua_stratagus_Window_new01);
20287 tolua_function(tolua_S,"new_local",tolua_stratagus_Window_new01_local);
20288 tolua_function(tolua_S,".call",tolua_stratagus_Window_new01_local);
20289 tolua_function(tolua_S,"new",tolua_stratagus_Window_new02);
20290 tolua_function(tolua_S,"new_local",tolua_stratagus_Window_new02_local);
20291 tolua_function(tolua_S,".call",tolua_stratagus_Window_new02_local);
20292 tolua_function(tolua_S,"setCaption",tolua_stratagus_Window_setCaption00);
20293 tolua_function(tolua_S,"getCaption",tolua_stratagus_Window_getCaption00);
20294 tolua_function(tolua_S,"setAlignment",tolua_stratagus_Window_setAlignment00);
20295 tolua_function(tolua_S,"getAlignment",tolua_stratagus_Window_getAlignment00);
20296 tolua_function(tolua_S,"setContent",tolua_stratagus_Window_setContent00);
20297 tolua_function(tolua_S,"getContent",tolua_stratagus_Window_getContent00);
20298 tolua_function(tolua_S,"setPadding",tolua_stratagus_Window_setPadding00);
20299 tolua_function(tolua_S,"getPadding",tolua_stratagus_Window_getPadding00);
20300 tolua_function(tolua_S,"setTitleBarHeight",tolua_stratagus_Window_setTitleBarHeight00);
20301 tolua_function(tolua_S,"getTitleBarHeight",tolua_stratagus_Window_getTitleBarHeight00);
20302 tolua_function(tolua_S,"setMovable",tolua_stratagus_Window_setMovable00);
20303 tolua_function(tolua_S,"isMovable",tolua_stratagus_Window_isMovable00);
20304 tolua_function(tolua_S,"resizeToContent",tolua_stratagus_Window_resizeToContent00);
20305 tolua_function(tolua_S,"setOpaque",tolua_stratagus_Window_setOpaque00);
20306 tolua_function(tolua_S,"isOpaque",tolua_stratagus_Window_isOpaque00);
20307 tolua_endmodule(tolua_S);
20308 #ifdef __cplusplus
20309 tolua_cclass(tolua_S,"Windows","Windows","Window",tolua_collect_Windows);
20310 #else
20311 tolua_cclass(tolua_S,"Windows","Windows","Window",NULL);
20312 #endif
20313 tolua_beginmodule(tolua_S,"Windows");
20314 tolua_function(tolua_S,"new",tolua_stratagus_Windows_new00);
20315 tolua_function(tolua_S,"new_local",tolua_stratagus_Windows_new00_local);
20316 tolua_function(tolua_S,".call",tolua_stratagus_Windows_new00_local);
20317 tolua_function(tolua_S,"add",tolua_stratagus_Windows_add00);
20318 tolua_endmodule(tolua_S);
20319 #ifdef __cplusplus
20320 tolua_cclass(tolua_S,"ScrollingWidget","ScrollingWidget","ScrollArea",tolua_collect_ScrollingWidget);
20321 #else
20322 tolua_cclass(tolua_S,"ScrollingWidget","ScrollingWidget","ScrollArea",NULL);
20323 #endif
20324 tolua_beginmodule(tolua_S,"ScrollingWidget");
20325 tolua_function(tolua_S,"new",tolua_stratagus_ScrollingWidget_new00);
20326 tolua_function(tolua_S,"new_local",tolua_stratagus_ScrollingWidget_new00_local);
20327 tolua_function(tolua_S,".call",tolua_stratagus_ScrollingWidget_new00_local);
20328 tolua_function(tolua_S,"add",tolua_stratagus_ScrollingWidget_add00);
20329 tolua_function(tolua_S,"restart",tolua_stratagus_ScrollingWidget_restart00);
20330 tolua_function(tolua_S,"setSpeed",tolua_stratagus_ScrollingWidget_setSpeed00);
20331 tolua_function(tolua_S,"getSpeed",tolua_stratagus_ScrollingWidget_getSpeed00);
20332 tolua_endmodule(tolua_S);
20333 tolua_cclass(tolua_S,"DropDown","DropDown","BasicContainer",NULL);
20334 tolua_beginmodule(tolua_S,"DropDown");
20335 tolua_function(tolua_S,"getSelected",tolua_stratagus_DropDown_getSelected00);
20336 tolua_function(tolua_S,"setSelected",tolua_stratagus_DropDown_setSelected00);
20337 tolua_function(tolua_S,"setScrollArea",tolua_stratagus_DropDown_setScrollArea00);
20338 tolua_function(tolua_S,"getScrollArea",tolua_stratagus_DropDown_getScrollArea00);
20339 tolua_function(tolua_S,"setListBox",tolua_stratagus_DropDown_setListBox00);
20340 tolua_function(tolua_S,"getListBox",tolua_stratagus_DropDown_getListBox00);
20341 tolua_endmodule(tolua_S);
20342 #ifdef __cplusplus
20343 tolua_cclass(tolua_S,"DropDownWidget","DropDownWidget","DropDown",tolua_collect_DropDownWidget);
20344 #else
20345 tolua_cclass(tolua_S,"DropDownWidget","DropDownWidget","DropDown",NULL);
20346 #endif
20347 tolua_beginmodule(tolua_S,"DropDownWidget");
20348 tolua_function(tolua_S,"new",tolua_stratagus_DropDownWidget_new00);
20349 tolua_function(tolua_S,"new_local",tolua_stratagus_DropDownWidget_new00_local);
20350 tolua_function(tolua_S,".call",tolua_stratagus_DropDownWidget_new00_local);
20351 tolua_function(tolua_S,"setList",tolua_stratagus_DropDownWidget_setList00);
20352 tolua_function(tolua_S,"getListBox",tolua_stratagus_DropDownWidget_getListBox00);
20353 tolua_function(tolua_S,"setSize",tolua_stratagus_DropDownWidget_setSize00);
20354 tolua_endmodule(tolua_S);
20355 #ifdef __cplusplus
20356 tolua_cclass(tolua_S,"StatBoxWidget","StatBoxWidget","Widget",tolua_collect_StatBoxWidget);
20357 #else
20358 tolua_cclass(tolua_S,"StatBoxWidget","StatBoxWidget","Widget",NULL);
20359 #endif
20360 tolua_beginmodule(tolua_S,"StatBoxWidget");
20361 tolua_function(tolua_S,"new",tolua_stratagus_StatBoxWidget_new00);
20362 tolua_function(tolua_S,"new_local",tolua_stratagus_StatBoxWidget_new00_local);
20363 tolua_function(tolua_S,".call",tolua_stratagus_StatBoxWidget_new00_local);
20364 tolua_function(tolua_S,"setCaption",tolua_stratagus_StatBoxWidget_setCaption00);
20365 tolua_function(tolua_S,"getCaption",tolua_stratagus_StatBoxWidget_getCaption00);
20366 tolua_function(tolua_S,"setPercent",tolua_stratagus_StatBoxWidget_setPercent00);
20367 tolua_function(tolua_S,"getPercent",tolua_stratagus_StatBoxWidget_getPercent00);
20368 tolua_endmodule(tolua_S);
20369 #ifdef __cplusplus
20370 tolua_cclass(tolua_S,"Container","Container","BasicContainer",tolua_collect_Container);
20371 #else
20372 tolua_cclass(tolua_S,"Container","Container","BasicContainer",NULL);
20373 #endif
20374 tolua_beginmodule(tolua_S,"Container");
20375 tolua_function(tolua_S,"new",tolua_stratagus_Container_new00);
20376 tolua_function(tolua_S,"new_local",tolua_stratagus_Container_new00_local);
20377 tolua_function(tolua_S,".call",tolua_stratagus_Container_new00_local);
20378 tolua_function(tolua_S,"setOpaque",tolua_stratagus_Container_setOpaque00);
20379 tolua_function(tolua_S,"isOpaque",tolua_stratagus_Container_isOpaque00);
20380 tolua_function(tolua_S,"add",tolua_stratagus_Container_add00);
20381 tolua_function(tolua_S,"remove",tolua_stratagus_Container_remove00);
20382 tolua_function(tolua_S,"clear",tolua_stratagus_Container_clear00);
20383 tolua_endmodule(tolua_S);
20384 #ifdef __cplusplus
20385 tolua_cclass(tolua_S,"CMenuScreen","MenuScreen","Container",tolua_collect_MenuScreen);
20386 #else
20387 tolua_cclass(tolua_S,"CMenuScreen","MenuScreen","Container",NULL);
20388 #endif
20389 tolua_beginmodule(tolua_S,"CMenuScreen");
20390 tolua_function(tolua_S,"new",tolua_stratagus_CMenuScreen_new00);
20391 tolua_function(tolua_S,"new_local",tolua_stratagus_CMenuScreen_new00_local);
20392 tolua_function(tolua_S,".call",tolua_stratagus_CMenuScreen_new00_local);
20393 tolua_function(tolua_S,"run",tolua_stratagus_CMenuScreen_run00);
20394 tolua_function(tolua_S,"stop",tolua_stratagus_CMenuScreen_stop00);
20395 tolua_function(tolua_S,"stopAll",tolua_stratagus_CMenuScreen_stopAll00);
20396 tolua_function(tolua_S,"addLogicCallback",tolua_stratagus_CMenuScreen_addLogicCallback00);
20397 tolua_function(tolua_S,"setDrawMenusUnder",tolua_stratagus_CMenuScreen_setDrawMenusUnder00);
20398 tolua_function(tolua_S,"getDrawMenusUnder",tolua_stratagus_CMenuScreen_getDrawMenusUnder00);
20399 tolua_endmodule(tolua_S);
20400
20401 { /* begin embedded lua code */
20402 int top = lua_gettop(tolua_S);
20403 static const unsigned char B[] = {
20404 10,102,117,110, 99,116,105,111,110, 32, 77,101,110,117, 83,
20405 99,114,101,101,110, 40, 41, 10,108,111, 99, 97,108, 32,109,
20406 101,110,117, 32, 61, 32, 67, 77,101,110,117, 83, 99,114,101,
20407 101,110, 40, 41, 10,108,111, 99, 97,108, 32,103,117,105, 99,
20408 104, 97,110, 97,100,100, 32, 61, 32, 67,111,110,116, 97,105,
20409 110,101,114, 46, 97,100,100, 10,102,117,110, 99,116,105,111,
20410 110, 32,109,101,110,117, 58, 97,100,100, 40,119,105,100,103,
20411 101,116, 44, 32,120, 44, 32,121, 41, 10,105,102, 32,110,111,
20412 116, 32,115,101,108,102, 46, 95, 97,100,100,101,100, 87,105,
20413 100,103,101,116,115, 32,116,104,101,110, 10,115,101,108,102,
20414 46, 95, 97,100,100,101,100, 87,105,100,103,101,116,115, 32,
20415 61, 32,123,125, 10,101,110,100, 10,115,101,108,102, 46, 95,
20416 97,100,100,101,100, 87,105,100,103,101,116,115, 91,119,105,
20417 100,103,101,116, 93, 32, 61, 32,116,114,117,101, 10,103,117,
20418 105, 99,104, 97,110, 97,100,100, 40,115,101,108,102, 44, 32,
20419 119,105,100,103,101,116, 44, 32,120, 44, 32,121, 41, 10,101,
20420 110,100, 10,114,101,116,117,114,110, 32,109,101,110,117, 10,
20421 101,110,100, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
20422 45, 45,32
20423 };
20424 tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 4");
20425 lua_settop(tolua_S, top);
20426 } /* end of embedded lua code */
20427
20428 tolua_function(tolua_S,"InitNetwork1",tolua_stratagus_InitNetwork100);
20429 tolua_function(tolua_S,"ExitNetwork1",tolua_stratagus_ExitNetwork100);
20430 tolua_function(tolua_S,"IsNetworkGame",tolua_stratagus_IsNetworkGame00);
20431 tolua_function(tolua_S,"NetworkSetupServerAddress",tolua_stratagus_NetworkSetupServerAddress00);
20432 tolua_function(tolua_S,"NetworkInitClientConnect",tolua_stratagus_NetworkInitClientConnect00);
20433 tolua_function(tolua_S,"NetworkInitServerConnect",tolua_stratagus_NetworkInitServerConnect00);
20434 tolua_function(tolua_S,"NetworkServerStartGame",tolua_stratagus_NetworkServerStartGame00);
20435 tolua_function(tolua_S,"NetworkProcessClientRequest",tolua_stratagus_NetworkProcessClientRequest00);
20436 tolua_function(tolua_S,"GetNetworkState",tolua_stratagus_GetNetworkState00);
20437 tolua_function(tolua_S,"NetworkServerResyncClients",tolua_stratagus_NetworkServerResyncClients00);
20438 tolua_function(tolua_S,"NetworkDetachFromServer",tolua_stratagus_NetworkDetachFromServer00);
20439 tolua_cclass(tolua_S,"CServerSetup","CServerSetup","",NULL);
20440 tolua_beginmodule(tolua_S,"CServerSetup");
20441 tolua_variable(tolua_S,"ResourcesOption",tolua_get_CServerSetup_unsigned_ResourcesOption,tolua_set_CServerSetup_unsigned_ResourcesOption);
20442 tolua_variable(tolua_S,"UnitsOption",tolua_get_CServerSetup_unsigned_UnitsOption,tolua_set_CServerSetup_unsigned_UnitsOption);
20443 tolua_variable(tolua_S,"FogOfWar",tolua_get_CServerSetup_unsigned_FogOfWar,tolua_set_CServerSetup_unsigned_FogOfWar);
20444 tolua_variable(tolua_S,"RevealMap",tolua_get_CServerSetup_unsigned_RevealMap,tolua_set_CServerSetup_unsigned_RevealMap);
20445 tolua_variable(tolua_S,"GameTypeOption",tolua_get_CServerSetup_unsigned_GameTypeOption,tolua_set_CServerSetup_unsigned_GameTypeOption);
20446 tolua_variable(tolua_S,"Difficulty",tolua_get_CServerSetup_unsigned_Difficulty,tolua_set_CServerSetup_unsigned_Difficulty);
20447 tolua_variable(tolua_S,"MapRichness",tolua_get_CServerSetup_unsigned_MapRichness,tolua_set_CServerSetup_unsigned_MapRichness);
20448 tolua_array(tolua_S,"CompOpt",tolua_get_stratagus_CServerSetup_CompOpt,tolua_set_stratagus_CServerSetup_CompOpt);
20449 tolua_array(tolua_S,"Ready",tolua_get_stratagus_CServerSetup_Ready,tolua_set_stratagus_CServerSetup_Ready);
20450 tolua_array(tolua_S,"LastFrame",tolua_get_stratagus_CServerSetup_LastFrame,tolua_set_stratagus_CServerSetup_LastFrame);
20451 tolua_endmodule(tolua_S);
20452 tolua_variable(tolua_S,"LocalSetupState",tolua_get_LocalSetupState,tolua_set_LocalSetupState);
20453 tolua_variable(tolua_S,"ServerSetupState",tolua_get_ServerSetupState,tolua_set_ServerSetupState);
20454 tolua_variable(tolua_S,"NetLocalHostsSlot",tolua_get_NetLocalHostsSlot,tolua_set_NetLocalHostsSlot);
20455 tolua_variable(tolua_S,"NetPlayerNameSize",tolua_get_NetPlayerNameSize,NULL);
20456 #ifdef __cplusplus
20457 tolua_cclass(tolua_S,"CNetworkHost","CNetworkHost","",tolua_collect_CNetworkHost);
20458 #else
20459 tolua_cclass(tolua_S,"CNetworkHost","CNetworkHost","",NULL);
20460 #endif
20461 tolua_beginmodule(tolua_S,"CNetworkHost");
20462 tolua_variable(tolua_S,"Host",tolua_get_CNetworkHost_unsigned_Host,tolua_set_CNetworkHost_unsigned_Host);
20463 tolua_variable(tolua_S,"Port",tolua_get_CNetworkHost_unsigned_Port,tolua_set_CNetworkHost_unsigned_Port);
20464 tolua_variable(tolua_S,"PlyNr",tolua_get_CNetworkHost_unsigned_PlyNr,tolua_set_CNetworkHost_unsigned_PlyNr);
20465 tolua_variable(tolua_S,"PlyName",tolua_get_CNetworkHost_PlyName,tolua_set_CNetworkHost_PlyName);
20466 tolua_endmodule(tolua_S);
20467 tolua_array(tolua_S,"Hosts",tolua_get_stratagus_Hosts,tolua_set_stratagus_Hosts);
20468 tolua_variable(tolua_S,"NetworkMapName",tolua_get_NetworkMapName,tolua_set_NetworkMapName);
20469 tolua_function(tolua_S,"NetworkGamePrepareGameSettings",tolua_stratagus_NetworkGamePrepareGameSettings00);
20470 tolua_function(tolua_S,"InitVideo",tolua_stratagus_InitVideo00);
20471 tolua_variable(tolua_S,"UseOpenGL",tolua_get_UseOpenGL,tolua_set_UseOpenGL);
20472 tolua_cclass(tolua_S,"CVideo","CVideo","",NULL);
20473 tolua_beginmodule(tolua_S,"CVideo");
20474 tolua_variable(tolua_S,"Width",tolua_get_CVideo_Width,tolua_set_CVideo_Width);
20475 tolua_variable(tolua_S,"Height",tolua_get_CVideo_Height,tolua_set_CVideo_Height);
20476 tolua_variable(tolua_S,"Depth",tolua_get_CVideo_Depth,tolua_set_CVideo_Depth);
20477 tolua_variable(tolua_S,"FullScreen",tolua_get_CVideo_FullScreen,tolua_set_CVideo_FullScreen);
20478 tolua_function(tolua_S,"ResizeScreen",tolua_stratagus_CVideo_ResizeScreen00);
20479 tolua_endmodule(tolua_S);
20480 tolua_variable(tolua_S,"Video",tolua_get_Video,tolua_set_Video);
20481 tolua_function(tolua_S,"ToggleFullScreen",tolua_stratagus_ToggleFullScreen00);
20482 tolua_cclass(tolua_S,"CGraphic","CGraphic","",NULL);
20483 tolua_beginmodule(tolua_S,"CGraphic");
20484 tolua_function(tolua_S,"New",tolua_stratagus_CGraphic_New00);
20485 tolua_function(tolua_S,"Free",tolua_stratagus_CGraphic_Free00);
20486 tolua_function(tolua_S,"Load",tolua_stratagus_CGraphic_Load00);
20487 tolua_function(tolua_S,"Resize",tolua_stratagus_CGraphic_Resize00);
20488 tolua_endmodule(tolua_S);
20489 tolua_cclass(tolua_S,"CPlayerColorGraphic","CPlayerColorGraphic","CGraphic",NULL);
20490 tolua_beginmodule(tolua_S,"CPlayerColorGraphic");
20491 tolua_function(tolua_S,"New",tolua_stratagus_CPlayerColorGraphic_New00);
20492 tolua_endmodule(tolua_S);
20493 #ifdef __cplusplus
20494 tolua_cclass(tolua_S,"CColor","CColor","",tolua_collect_CColor);
20495 #else
20496 tolua_cclass(tolua_S,"CColor","CColor","",NULL);
20497 #endif
20498 tolua_beginmodule(tolua_S,"CColor");
20499 tolua_function(tolua_S,"new",tolua_stratagus_CColor_new00);
20500 tolua_function(tolua_S,"new_local",tolua_stratagus_CColor_new00_local);
20501 tolua_function(tolua_S,".call",tolua_stratagus_CColor_new00_local);
20502 tolua_variable(tolua_S,"R",tolua_get_CColor_unsigned_R,tolua_set_CColor_unsigned_R);
20503 tolua_variable(tolua_S,"G",tolua_get_CColor_unsigned_G,tolua_set_CColor_unsigned_G);
20504 tolua_variable(tolua_S,"B",tolua_get_CColor_unsigned_B,tolua_set_CColor_unsigned_B);
20505 tolua_variable(tolua_S,"A",tolua_get_CColor_unsigned_A,tolua_set_CColor_unsigned_A);
20506 tolua_endmodule(tolua_S);
20507 tolua_variable(tolua_S,"UseGLTextureCompression",tolua_get_UseGLTextureCompression,tolua_set_UseGLTextureCompression);
20508 tolua_cclass(tolua_S,"CFont","CFont","",NULL);
20509 tolua_beginmodule(tolua_S,"CFont");
20510 tolua_function(tolua_S,"New",tolua_stratagus_CFont_New00);
20511 tolua_function(tolua_S,"Get",tolua_stratagus_CFont_Get00);
20512 tolua_function(tolua_S,"Height",tolua_stratagus_CFont_Height00);
20513 tolua_function(tolua_S,"Width",tolua_stratagus_CFont_Width00);
20514 tolua_function(tolua_S,"PlainText",tolua_stratagus_CFont_PlainText00);
20515 tolua_endmodule(tolua_S);
20516 tolua_constant(tolua_S,"MaxFontColors",MaxFontColors);
20517 tolua_cclass(tolua_S,"CFontColor","CFontColor","",NULL);
20518 tolua_beginmodule(tolua_S,"CFontColor");
20519 tolua_function(tolua_S,"New",tolua_stratagus_CFontColor_New00);
20520 tolua_function(tolua_S,"Get",tolua_stratagus_CFontColor_Get00);
20521 tolua_array(tolua_S,"Colors",tolua_get_stratagus_CFontColor_Colors,tolua_set_stratagus_CFontColor_Colors);
20522 tolua_endmodule(tolua_S);
20523 tolua_constant(tolua_S,"PlayerNeutral",PlayerNeutral);
20524 tolua_constant(tolua_S,"PlayerNobody",PlayerNobody);
20525 tolua_constant(tolua_S,"PlayerComputer",PlayerComputer);
20526 tolua_constant(tolua_S,"PlayerPerson",PlayerPerson);
20527 tolua_constant(tolua_S,"PlayerRescuePassive",PlayerRescuePassive);
20528 tolua_constant(tolua_S,"PlayerRescueActive",PlayerRescueActive);
20529 #ifdef __cplusplus
20530 tolua_cclass(tolua_S,"CPlayer","CPlayer","",tolua_collect_CPlayer);
20531 #else
20532 tolua_cclass(tolua_S,"CPlayer","CPlayer","",NULL);
20533 #endif
20534 tolua_beginmodule(tolua_S,"CPlayer");
20535 tolua_variable(tolua_S,"Index",tolua_get_CPlayer_Index,tolua_set_CPlayer_Index);
20536 tolua_variable(tolua_S,"Name",tolua_get_CPlayer_Name,tolua_set_CPlayer_Name);
20537 tolua_variable(tolua_S,"Type",tolua_get_CPlayer_Type,tolua_set_CPlayer_Type);
20538 tolua_variable(tolua_S,"AiName",tolua_get_CPlayer_AiName,tolua_set_CPlayer_AiName);
20539 tolua_variable(tolua_S,"StartX",tolua_get_CPlayer_StartX,tolua_set_CPlayer_StartX);
20540 tolua_variable(tolua_S,"StartY",tolua_get_CPlayer_StartY,tolua_set_CPlayer_StartY);
20541 tolua_function(tolua_S,"SetStartView",tolua_stratagus_CPlayer_SetStartView00);
20542 tolua_variable(tolua_S,"EnergyProductionRate",tolua_get_CPlayer_EnergyProductionRate,tolua_set_CPlayer_EnergyProductionRate);
20543 tolua_variable(tolua_S,"MagmaProductionRate",tolua_get_CPlayer_MagmaProductionRate,tolua_set_CPlayer_MagmaProductionRate);
20544 tolua_variable(tolua_S,"EnergyStored",tolua_get_CPlayer_EnergyStored,tolua_set_CPlayer_EnergyStored);
20545 tolua_variable(tolua_S,"MagmaStored",tolua_get_CPlayer_MagmaStored,tolua_set_CPlayer_MagmaStored);
20546 tolua_variable(tolua_S,"EnergyStorageCapacity",tolua_get_CPlayer_EnergyStorageCapacity,tolua_set_CPlayer_EnergyStorageCapacity);
20547 tolua_variable(tolua_S,"MagmaStorageCapacity",tolua_get_CPlayer_MagmaStorageCapacity,tolua_set_CPlayer_MagmaStorageCapacity);
20548 tolua_array(tolua_S,"UnitTypesCount",tolua_get_stratagus_CPlayer_UnitTypesCount,NULL);
20549 tolua_variable(tolua_S,"AiEnabled",tolua_get_CPlayer_AiEnabled,tolua_set_CPlayer_AiEnabled);
20550 tolua_array(tolua_S,"Units",tolua_get_stratagus_CPlayer_Units,tolua_set_stratagus_CPlayer_Units);
20551 tolua_variable(tolua_S,"TotalNumUnits",tolua_get_CPlayer_TotalNumUnits,tolua_set_CPlayer_TotalNumUnits);
20552 tolua_variable(tolua_S,"NumBuildings",tolua_get_CPlayer_NumBuildings,tolua_set_CPlayer_NumBuildings);
20553 tolua_variable(tolua_S,"UnitLimit",tolua_get_CPlayer_UnitLimit,tolua_set_CPlayer_UnitLimit);
20554 tolua_variable(tolua_S,"BuildingLimit",tolua_get_CPlayer_BuildingLimit,tolua_set_CPlayer_BuildingLimit);
20555 tolua_variable(tolua_S,"TotalUnitLimit",tolua_get_CPlayer_TotalUnitLimit,tolua_set_CPlayer_TotalUnitLimit);
20556 tolua_variable(tolua_S,"Score",tolua_get_CPlayer_Score,tolua_set_CPlayer_Score);
20557 tolua_variable(tolua_S,"TotalUnits",tolua_get_CPlayer_TotalUnits,tolua_set_CPlayer_TotalUnits);
20558 tolua_variable(tolua_S,"TotalBuildings",tolua_get_CPlayer_TotalBuildings,tolua_set_CPlayer_TotalBuildings);
20559 tolua_variable(tolua_S,"TotalEnergy",tolua_get_CPlayer_TotalEnergy,tolua_set_CPlayer_TotalEnergy);
20560 tolua_variable(tolua_S,"TotalMagma",tolua_get_CPlayer_TotalMagma,tolua_set_CPlayer_TotalMagma);
20561 tolua_variable(tolua_S,"TotalRazings",tolua_get_CPlayer_TotalRazings,tolua_set_CPlayer_TotalRazings);
20562 tolua_variable(tolua_S,"TotalKills",tolua_get_CPlayer_TotalKills,tolua_set_CPlayer_TotalKills);
20563 tolua_function(tolua_S,"IsEnemy",tolua_stratagus_CPlayer_IsEnemy00);
20564 tolua_function(tolua_S,"IsEnemy",tolua_stratagus_CPlayer_IsEnemy01);
20565 tolua_function(tolua_S,"IsAllied",tolua_stratagus_CPlayer_IsAllied00);
20566 tolua_function(tolua_S,"IsAllied",tolua_stratagus_CPlayer_IsAllied01);
20567 tolua_function(tolua_S,"IsSharedVision",tolua_stratagus_CPlayer_IsSharedVision00);
20568 tolua_function(tolua_S,"IsSharedVision",tolua_stratagus_CPlayer_IsSharedVision01);
20569 tolua_function(tolua_S,"IsBothSharedVision",tolua_stratagus_CPlayer_IsBothSharedVision00);
20570 tolua_function(tolua_S,"IsBothSharedVision",tolua_stratagus_CPlayer_IsBothSharedVision01);
20571 tolua_function(tolua_S,"IsTeamed",tolua_stratagus_CPlayer_IsTeamed00);
20572 tolua_function(tolua_S,"IsTeamed",tolua_stratagus_CPlayer_IsTeamed01);
20573 tolua_endmodule(tolua_S);
20574 tolua_array(tolua_S,"Players",tolua_get_stratagus_Players,tolua_set_stratagus_Players);
20575 tolua_variable(tolua_S,"ThisPlayer",tolua_get_ThisPlayer_ptr,tolua_set_ThisPlayer_ptr);
20576 tolua_function(tolua_S,"ChangeUnitsOwner",tolua_stratagus_ChangeUnitsOwner00);
20577 tolua_cclass(tolua_S,"CUnitType","CUnitType","",NULL);
20578 tolua_beginmodule(tolua_S,"CUnitType");
20579 tolua_variable(tolua_S,"Ident",tolua_get_CUnitType_Ident,tolua_set_CUnitType_Ident);
20580 tolua_variable(tolua_S,"Name",tolua_get_CUnitType_Name,tolua_set_CUnitType_Name);
20581 tolua_variable(tolua_S,"Slot",tolua_get_CUnitType_Slot,NULL);
20582 tolua_variable(tolua_S,"MinAttackRange",tolua_get_CUnitType_MinAttackRange,tolua_set_CUnitType_MinAttackRange);
20583 tolua_variable(tolua_S,"MaxEnergyUtilizationRate",tolua_get_CUnitType_MaxEnergyUtilizationRate,tolua_set_CUnitType_MaxEnergyUtilizationRate);
20584 tolua_variable(tolua_S,"MaxMagmaUtilizationRate",tolua_get_CUnitType_MaxMagmaUtilizationRate,tolua_set_CUnitType_MaxMagmaUtilizationRate);
20585 tolua_variable(tolua_S,"EnergyProductionRate",tolua_get_CUnitType_EnergyProductionRate,tolua_set_CUnitType_EnergyProductionRate);
20586 tolua_variable(tolua_S,"MagmaProductionRate",tolua_get_CUnitType_MagmaProductionRate,tolua_set_CUnitType_MagmaProductionRate);
20587 tolua_variable(tolua_S,"EnergyValue",tolua_get_CUnitType_EnergyValue,tolua_set_CUnitType_EnergyValue);
20588 tolua_variable(tolua_S,"MagmaValue",tolua_get_CUnitType_MagmaValue,tolua_set_CUnitType_MagmaValue);
20589 tolua_variable(tolua_S,"EnergyStorageCapacity",tolua_get_CUnitType_EnergyStorageCapacity,tolua_set_CUnitType_EnergyStorageCapacity);
20590 tolua_variable(tolua_S,"MagmaStorageCapacity",tolua_get_CUnitType_MagmaStorageCapacity,tolua_set_CUnitType_MagmaStorageCapacity);
20591 tolua_endmodule(tolua_S);
20592 tolua_function(tolua_S,"UnitTypeByIdent",tolua_stratagus_UnitTypeByIdent00);
20593 tolua_cclass(tolua_S,"CUnit","CUnit","",NULL);
20594 tolua_beginmodule(tolua_S,"CUnit");
20595 tolua_variable(tolua_S,"Slot",tolua_get_CUnit_Slot,NULL);
20596 tolua_variable(tolua_S,"X",tolua_get_CUnit_X,tolua_set_CUnit_X);
20597 tolua_variable(tolua_S,"Y",tolua_get_CUnit_Y,tolua_set_CUnit_Y);
20598 tolua_variable(tolua_S,"Type",tolua_get_CUnit_Type_ptr,tolua_set_CUnit_Type_ptr);
20599 tolua_variable(tolua_S,"Player",tolua_get_CUnit_Player_ptr,tolua_set_CUnit_Player_ptr);
20600 tolua_endmodule(tolua_S);
20601 tolua_cclass(tolua_S,"CPreference","CPreference","",NULL);
20602 tolua_beginmodule(tolua_S,"CPreference");
20603 tolua_variable(tolua_S,"ShowSightRange",tolua_get_CPreference_ShowSightRange,tolua_set_CPreference_ShowSightRange);
20604 tolua_variable(tolua_S,"ShowReactionRange",tolua_get_CPreference_ShowReactionRange,tolua_set_CPreference_ShowReactionRange);
20605 tolua_variable(tolua_S,"ShowAttackRange",tolua_get_CPreference_ShowAttackRange,tolua_set_CPreference_ShowAttackRange);
20606 tolua_variable(tolua_S,"ShowOrders",tolua_get_CPreference_unsigned_ShowOrders,tolua_set_CPreference_unsigned_ShowOrders);
20607 tolua_endmodule(tolua_S);
20608 tolua_variable(tolua_S,"Preference",tolua_get_Preference,tolua_set_Preference);
20609 tolua_function(tolua_S,"GetEffectsVolume",tolua_stratagus_GetEffectsVolume00);
20610 tolua_function(tolua_S,"SetEffectsVolume",tolua_stratagus_SetEffectsVolume00);
20611 tolua_function(tolua_S,"GetMusicVolume",tolua_stratagus_GetMusicVolume00);
20612 tolua_function(tolua_S,"SetMusicVolume",tolua_stratagus_SetMusicVolume00);
20613 tolua_function(tolua_S,"SetEffectsEnabled",tolua_stratagus_SetEffectsEnabled00);
20614 tolua_function(tolua_S,"IsEffectsEnabled",tolua_stratagus_IsEffectsEnabled00);
20615 tolua_function(tolua_S,"SetMusicEnabled",tolua_stratagus_SetMusicEnabled00);
20616 tolua_function(tolua_S,"IsMusicEnabled",tolua_stratagus_IsMusicEnabled00);
20617 tolua_function(tolua_S,"PlayFile",tolua_stratagus_PlayFile00);
20618
20619 { /* begin embedded lua code */
20620 int top = lua_gettop(tolua_S);
20621 static const unsigned char B[] = {
20622 10,102,117,110, 99,116,105,111,110, 32, 80,108, 97,121, 83,
20623 111,117,110,100, 70,105,108,101, 40,102,105,108,101, 44, 32,
20624 99, 97,108,108, 98, 97, 99,107, 41, 10,114,101,116,117,114,
20625 110, 32, 80,108, 97,121, 70,105,108,101, 40,102,105,108,101,
20626 44, 32, 76,117, 97, 65, 99,116,105,111,110, 76,105,115,116,
20627 101,110,101,114, 58,110,101,119, 40, 99, 97,108,108, 98, 97,
20628 99,107, 41, 41, 10,101,110,100, 45, 45, 45, 45, 45, 45, 45,
20629 45, 45, 45, 45, 45, 45, 45,32
20630 };
20631 tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 5");
20632 lua_settop(tolua_S, top);
20633 } /* end of embedded lua code */
20634
20635 tolua_function(tolua_S,"PlayMusic",tolua_stratagus_PlayMusic00);
20636 tolua_function(tolua_S,"StopMusic",tolua_stratagus_StopMusic00);
20637 tolua_function(tolua_S,"SetChannelVolume",tolua_stratagus_SetChannelVolume00);
20638 tolua_function(tolua_S,"SetChannelStereo",tolua_stratagus_SetChannelStereo00);
20639 tolua_function(tolua_S,"StopChannel",tolua_stratagus_StopChannel00);
20640 tolua_function(tolua_S,"StopAllChannels",tolua_stratagus_StopAllChannels00);
20641 tolua_constant(tolua_S,"EditorNotRunning",EditorNotRunning);
20642 tolua_constant(tolua_S,"EditorStarted",EditorStarted);
20643 tolua_constant(tolua_S,"EditorCommandLine",EditorCommandLine);
20644 tolua_constant(tolua_S,"EditorEditing",EditorEditing);
20645 tolua_cclass(tolua_S,"CEditor","CEditor","",NULL);
20646 tolua_beginmodule(tolua_S,"CEditor");
20647 tolua_variable(tolua_S,"UnitTypes",tolua_get_CEditor_UnitTypes,tolua_set_CEditor_UnitTypes);
20648 tolua_variable(tolua_S,"StartUnit",tolua_get_CEditor_StartUnit_ptr,NULL);
20649 tolua_variable(tolua_S,"ShowTerrainFlags",tolua_get_CEditor_ShowTerrainFlags,tolua_set_CEditor_ShowTerrainFlags);
20650 tolua_variable(tolua_S,"Running",tolua_get_CEditor_Running,tolua_set_CEditor_Running);
20651 tolua_function(tolua_S,"TileSelectedPatch",tolua_stratagus_CEditor_TileSelectedPatch00);
20652 tolua_endmodule(tolua_S);
20653 tolua_function(tolua_S,"SetEditorSelectIcon",tolua_stratagus_SetEditorSelectIcon00);
20654 tolua_function(tolua_S,"SetEditorUnitsIcon",tolua_stratagus_SetEditorUnitsIcon00);
20655 tolua_function(tolua_S,"SetEditorPatchIcon",tolua_stratagus_SetEditorPatchIcon00);
20656 tolua_function(tolua_S,"SetEditorStartUnit",tolua_stratagus_SetEditorStartUnit00);
20657 tolua_variable(tolua_S,"Editor",tolua_get_Editor,tolua_set_Editor);
20658 tolua_function(tolua_S,"StartEditor",tolua_stratagus_StartEditor00);
20659 tolua_function(tolua_S,"EditorSaveMap",tolua_stratagus_EditorSaveMap00);
20660 tolua_function(tolua_S,"StartPatchEditor",tolua_stratagus_StartPatchEditor00);
20661 tolua_function(tolua_S,"IsReplayGame",tolua_stratagus_IsReplayGame00);
20662 tolua_function(tolua_S,"StartMap",tolua_stratagus_StartMap00);
20663 tolua_function(tolua_S,"StartReplay",tolua_stratagus_StartReplay00);
20664 tolua_function(tolua_S,"StartSavedGame",tolua_stratagus_StartSavedGame00);
20665 tolua_constant(tolua_S,"GameNoResult",GameNoResult);
20666 tolua_constant(tolua_S,"GameVictory",GameVictory);
20667 tolua_constant(tolua_S,"GameDefeat",GameDefeat);
20668 tolua_constant(tolua_S,"GameDraw",GameDraw);
20669 tolua_constant(tolua_S,"GameQuitToMenu",GameQuitToMenu);
20670 tolua_constant(tolua_S,"GameRestart",GameRestart);
20671 tolua_variable(tolua_S,"GameResult",tolua_get_GameResult,tolua_set_GameResult);
20672 tolua_function(tolua_S,"StopGame",tolua_stratagus_StopGame00);
20673 tolua_variable(tolua_S,"GameRunning",tolua_get_GameRunning,tolua_set_GameRunning);
20674 tolua_function(tolua_S,"SetGamePaused",tolua_stratagus_SetGamePaused00);
20675 tolua_function(tolua_S,"GetGamePaused",tolua_stratagus_GetGamePaused00);
20676 tolua_variable(tolua_S,"GamePaused",tolua_get_GamePaused,tolua_set_GamePaused);
20677 tolua_function(tolua_S,"SetGameSpeed",tolua_stratagus_SetGameSpeed00);
20678 tolua_function(tolua_S,"GetGameSpeed",tolua_stratagus_GetGameSpeed00);
20679 tolua_variable(tolua_S,"GameSpeed",tolua_get_GameSpeed,tolua_set_GameSpeed);
20680 tolua_variable(tolua_S,"GameObserve",tolua_get_GameObserve,tolua_set_GameObserve);
20681 tolua_variable(tolua_S,"GameCycle",tolua_get_unsigned_GameCycle,tolua_set_unsigned_GameCycle);
20682 #ifdef __cplusplus
20683 tolua_cclass(tolua_S,"SettingsPresets","SettingsPresets","",tolua_collect_SettingsPresets);
20684 #else
20685 tolua_cclass(tolua_S,"SettingsPresets","SettingsPresets","",NULL);
20686 #endif
20687 tolua_beginmodule(tolua_S,"SettingsPresets");
20688 tolua_variable(tolua_S,"Team",tolua_get_SettingsPresets_Team,tolua_set_SettingsPresets_Team);
20689 tolua_variable(tolua_S,"Type",tolua_get_SettingsPresets_Type,tolua_set_SettingsPresets_Type);
20690 tolua_endmodule(tolua_S);
20691 tolua_cclass(tolua_S,"Settings","Settings","",NULL);
20692 tolua_beginmodule(tolua_S,"Settings");
20693 tolua_variable(tolua_S,"NetGameType",tolua_get_Settings_NetGameType,tolua_set_Settings_NetGameType);
20694 tolua_array(tolua_S,"Presets",tolua_get_stratagus_Settings_Presets,tolua_set_stratagus_Settings_Presets);
20695 tolua_variable(tolua_S,"Resources",tolua_get_Settings_Resources,tolua_set_Settings_Resources);
20696 tolua_variable(tolua_S,"NumUnits",tolua_get_Settings_NumUnits,tolua_set_Settings_NumUnits);
20697 tolua_variable(tolua_S,"Opponents",tolua_get_Settings_Opponents,tolua_set_Settings_Opponents);
20698 tolua_variable(tolua_S,"Difficulty",tolua_get_Settings_Difficulty,tolua_set_Settings_Difficulty);
20699 tolua_variable(tolua_S,"GameType",tolua_get_Settings_GameType,tolua_set_Settings_GameType);
20700 tolua_variable(tolua_S,"NoFogOfWar",tolua_get_Settings_NoFogOfWar,tolua_set_Settings_NoFogOfWar);
20701 tolua_variable(tolua_S,"RevealMap",tolua_get_Settings_RevealMap,tolua_set_Settings_RevealMap);
20702 tolua_variable(tolua_S,"MapRichness",tolua_get_Settings_MapRichness,tolua_set_Settings_MapRichness);
20703 tolua_endmodule(tolua_S);
20704 tolua_variable(tolua_S,"GameSettings",tolua_get_GameSettings,tolua_set_GameSettings);
20705 tolua_constant(tolua_S,"SettingsPresetMapDefault",SettingsPresetMapDefault);
20706 tolua_constant(tolua_S,"SettingsGameTypeMapDefault",SettingsGameTypeMapDefault);
20707 tolua_constant(tolua_S,"SettingsGameTypeMelee",SettingsGameTypeMelee);
20708 tolua_constant(tolua_S,"SettingsGameTypeFreeForAll",SettingsGameTypeFreeForAll);
20709 tolua_constant(tolua_S,"SettingsGameTypeTopVsBottom",SettingsGameTypeTopVsBottom);
20710 tolua_constant(tolua_S,"SettingsGameTypeLeftVsRight",SettingsGameTypeLeftVsRight);
20711 tolua_constant(tolua_S,"SettingsGameTypeManVsMachine",SettingsGameTypeManVsMachine);
20712 tolua_constant(tolua_S,"SettingsGameTypeManTeamVsMachine",SettingsGameTypeManTeamVsMachine);
20713 tolua_array(tolua_S,"AlliedUnitRecyclingEfficiency",tolua_get_stratagus_AlliedUnitRecyclingEfficiency,tolua_set_stratagus_AlliedUnitRecyclingEfficiency);
20714 tolua_array(tolua_S,"EnemyUnitRecyclingEfficiency",tolua_get_stratagus_EnemyUnitRecyclingEfficiency,tolua_set_stratagus_EnemyUnitRecyclingEfficiency);
20715 tolua_cclass(tolua_S,"CMapInfo","CMapInfo","",NULL);
20716 tolua_beginmodule(tolua_S,"CMapInfo");
20717 tolua_variable(tolua_S,"Description",tolua_get_CMapInfo_Description,tolua_set_CMapInfo_Description);
20718 tolua_variable(tolua_S,"MapWidth",tolua_get_CMapInfo_MapWidth,tolua_set_CMapInfo_MapWidth);
20719 tolua_variable(tolua_S,"MapHeight",tolua_get_CMapInfo_MapHeight,tolua_set_CMapInfo_MapHeight);
20720 tolua_array(tolua_S,"PlayerType",tolua_get_stratagus_CMapInfo_PlayerType,tolua_set_stratagus_CMapInfo_PlayerType);
20721 tolua_endmodule(tolua_S);
20722 tolua_cclass(tolua_S,"CMap","CMap","",NULL);
20723 tolua_beginmodule(tolua_S,"CMap");
20724 tolua_variable(tolua_S,"Info",tolua_get_CMap_Info,tolua_set_CMap_Info);
20725 tolua_variable(tolua_S,"PatchManager",tolua_get_CMap_PatchManager,tolua_set_CMap_PatchManager);
20726 tolua_endmodule(tolua_S);
20727 tolua_variable(tolua_S,"Map",tolua_get_Map,tolua_set_Map);
20728 tolua_cclass(tolua_S,"CPatchType","CPatchType","",NULL);
20729 tolua_beginmodule(tolua_S,"CPatchType");
20730 tolua_function(tolua_S,"getGraphic",tolua_stratagus_CPatchType_getGraphic00);
20731 tolua_function(tolua_S,"getTileWidth",tolua_stratagus_CPatchType_getTileWidth00);
20732 tolua_function(tolua_S,"getTileHeight",tolua_stratagus_CPatchType_getTileHeight00);
20733 tolua_function(tolua_S,"getFlag",tolua_stratagus_CPatchType_getFlag00);
20734 tolua_endmodule(tolua_S);
20735 tolua_cclass(tolua_S,"CPatch","CPatch","",NULL);
20736 tolua_beginmodule(tolua_S,"CPatch");
20737 tolua_function(tolua_S,"getType",tolua_stratagus_CPatch_getType00);
20738 tolua_function(tolua_S,"setPos",tolua_stratagus_CPatch_setPos00);
20739 tolua_function(tolua_S,"setX",tolua_stratagus_CPatch_setX00);
20740 tolua_function(tolua_S,"getX",tolua_stratagus_CPatch_getX00);
20741 tolua_function(tolua_S,"setY",tolua_stratagus_CPatch_setY00);
20742 tolua_function(tolua_S,"getY",tolua_stratagus_CPatch_getY00);
20743 tolua_endmodule(tolua_S);
20744 tolua_cclass(tolua_S,"CPatchManager","CPatchManager","",NULL);
20745 tolua_beginmodule(tolua_S,"CPatchManager");
20746 tolua_function(tolua_S,"add",tolua_stratagus_CPatchManager_add00);
20747 tolua_function(tolua_S,"moveToTop",tolua_stratagus_CPatchManager_moveToTop00);
20748 tolua_function(tolua_S,"moveToBottom",tolua_stratagus_CPatchManager_moveToBottom00);
20749 tolua_function(tolua_S,"getPatch",tolua_stratagus_CPatchManager_getPatch00);
20750 tolua_function(tolua_S,"getPatchTypeNames",tolua_stratagus_CPatchManager_getPatchTypeNames00);
20751 tolua_function(tolua_S,"getPatchTypeNamesUsingGraphic",tolua_stratagus_CPatchManager_getPatchTypeNamesUsingGraphic00);
20752 tolua_function(tolua_S,"newPatchType",tolua_stratagus_CPatchManager_newPatchType00);
20753 tolua_function(tolua_S,"computePatchSize",tolua_stratagus_CPatchManager_computePatchSize00);
20754 tolua_endmodule(tolua_S);
20755 tolua_variable(tolua_S,"AStarFixedUnitCrossingCost",tolua_get_AStarFixedUnitCrossingCost,tolua_set_AStarFixedUnitCrossingCost);
20756 tolua_variable(tolua_S,"AStarMovingUnitCrossingCost",tolua_get_AStarMovingUnitCrossingCost,tolua_set_AStarMovingUnitCrossingCost);
20757 tolua_variable(tolua_S,"AStarKnowUnseenTerrain",tolua_get_AStarKnowUnseenTerrain,tolua_set_AStarKnowUnseenTerrain);
20758 tolua_variable(tolua_S,"AStarUnknownTerrainCost",tolua_get_AStarUnknownTerrainCost,tolua_set_AStarUnknownTerrainCost);
20759 tolua_function(tolua_S,"GetNumOpponents",tolua_stratagus_GetNumOpponents00);
20760 tolua_function(tolua_S,"GetTimer",tolua_stratagus_GetTimer00);
20761 tolua_function(tolua_S,"ActionVictory",tolua_stratagus_ActionVictory00);
20762 tolua_function(tolua_S,"ActionDefeat",tolua_stratagus_ActionDefeat00);
20763 tolua_function(tolua_S,"ActionDraw",tolua_stratagus_ActionDraw00);
20764 tolua_function(tolua_S,"ActionSetTimer",tolua_stratagus_ActionSetTimer00);
20765 tolua_function(tolua_S,"ActionStartTimer",tolua_stratagus_ActionStartTimer00);
20766 tolua_function(tolua_S,"ActionStopTimer",tolua_stratagus_ActionStopTimer00);
20767 tolua_function(tolua_S,"SetTrigger",tolua_stratagus_SetTrigger00);
20768 #ifdef __cplusplus
20769 tolua_cclass(tolua_S,"CPosition","CPosition","",tolua_collect_CPosition);
20770 #else
20771 tolua_cclass(tolua_S,"CPosition","CPosition","",NULL);
20772 #endif
20773 tolua_beginmodule(tolua_S,"CPosition");
20774 tolua_function(tolua_S,"new",tolua_stratagus_CPosition_new00);
20775 tolua_function(tolua_S,"new_local",tolua_stratagus_CPosition_new00_local);
20776 tolua_function(tolua_S,".call",tolua_stratagus_CPosition_new00_local);
20777 tolua_variable(tolua_S,"x",tolua_get_CPosition_x,tolua_set_CPosition_x);
20778 tolua_variable(tolua_S,"y",tolua_get_CPosition_y,tolua_set_CPosition_y);
20779 tolua_endmodule(tolua_S);
20780 #ifdef __cplusplus
20781 tolua_cclass(tolua_S,"GraphicAnimation","GraphicAnimation","Animation",tolua_collect_GraphicAnimation);
20782 #else
20783 tolua_cclass(tolua_S,"GraphicAnimation","GraphicAnimation","Animation",NULL);
20784 #endif
20785 tolua_beginmodule(tolua_S,"GraphicAnimation");
20786 tolua_function(tolua_S,"new",tolua_stratagus_GraphicAnimation_new00);
20787 tolua_function(tolua_S,"new_local",tolua_stratagus_GraphicAnimation_new00_local);
20788 tolua_function(tolua_S,".call",tolua_stratagus_GraphicAnimation_new00_local);
20789 tolua_function(tolua_S,"clone",tolua_stratagus_GraphicAnimation_clone00);
20790 tolua_endmodule(tolua_S);
20791 tolua_cclass(tolua_S,"CParticle","CParticle","",NULL);
20792 tolua_beginmodule(tolua_S,"CParticle");
20793 tolua_function(tolua_S,"clone",tolua_stratagus_CParticle_clone00);
20794 tolua_endmodule(tolua_S);
20795 #ifdef __cplusplus
20796 tolua_cclass(tolua_S,"StaticParticle","StaticParticle","CParticle",tolua_collect_StaticParticle);
20797 #else
20798 tolua_cclass(tolua_S,"StaticParticle","StaticParticle","CParticle",NULL);
20799 #endif
20800 tolua_beginmodule(tolua_S,"StaticParticle");
20801 tolua_function(tolua_S,"new",tolua_stratagus_StaticParticle_new00);
20802 tolua_function(tolua_S,"new_local",tolua_stratagus_StaticParticle_new00_local);
20803 tolua_function(tolua_S,".call",tolua_stratagus_StaticParticle_new00_local);
20804 tolua_endmodule(tolua_S);
20805 #ifdef __cplusplus
20806 tolua_cclass(tolua_S,"CChunkParticle","CChunkParticle","CParticle",tolua_collect_CChunkParticle);
20807 #else
20808 tolua_cclass(tolua_S,"CChunkParticle","CChunkParticle","CParticle",NULL);
20809 #endif
20810 tolua_beginmodule(tolua_S,"CChunkParticle");
20811 tolua_function(tolua_S,"new",tolua_stratagus_CChunkParticle_new00);
20812 tolua_function(tolua_S,"new_local",tolua_stratagus_CChunkParticle_new00_local);
20813 tolua_function(tolua_S,".call",tolua_stratagus_CChunkParticle_new00_local);
20814 tolua_endmodule(tolua_S);
20815 tolua_cclass(tolua_S,"CSmokeParticle","CSmokeParticle","CParticle",NULL);
20816 tolua_beginmodule(tolua_S,"CSmokeParticle");
20817 tolua_endmodule(tolua_S);
20818 #ifdef __cplusplus
20819 tolua_cclass(tolua_S,"CParticleManager","CParticleManager","",tolua_collect_CParticleManager);
20820 #else
20821 tolua_cclass(tolua_S,"CParticleManager","CParticleManager","",NULL);
20822 #endif
20823 tolua_beginmodule(tolua_S,"CParticleManager");
20824 tolua_function(tolua_S,"new",tolua_stratagus_CParticleManager_new00);
20825 tolua_function(tolua_S,"new_local",tolua_stratagus_CParticleManager_new00_local);
20826 tolua_function(tolua_S,".call",tolua_stratagus_CParticleManager_new00_local);
20827 tolua_function(tolua_S,"delete",tolua_stratagus_CParticleManager_delete00);
20828 tolua_function(tolua_S,"add",tolua_stratagus_CParticleManager_add00);
20829 tolua_endmodule(tolua_S);
20830 tolua_variable(tolua_S,"ParticleManager",tolua_get_ParticleManager,tolua_set_ParticleManager);
20831 tolua_function(tolua_S,"Translate",tolua_stratagus_Translate00);
20832 tolua_function(tolua_S,"AddTranslation",tolua_stratagus_AddTranslation00);
20833 tolua_function(tolua_S,"LoadPO",tolua_stratagus_LoadPO00);
20834 tolua_function(tolua_S,"SetTranslationsFiles",tolua_stratagus_SetTranslationsFiles00);
20835 tolua_variable(tolua_S,"StratagusTranslation",tolua_get_StratagusTranslation,tolua_set_StratagusTranslation);
20836 tolua_variable(tolua_S,"GameTranslation",tolua_get_GameTranslation,tolua_set_GameTranslation);
20837 tolua_function(tolua_S,"SaveGame",tolua_stratagus_SaveGame00);
20838 tolua_function(tolua_S,"_",tolua_stratagus__00);
20839 tolua_function(tolua_S,"SyncRand",tolua_stratagus_SyncRand00);
20840 tolua_function(tolua_S,"SyncRand",tolua_stratagus_SyncRand01);
20841 tolua_function(tolua_S,"Exit",tolua_stratagus_Exit00);
20842 tolua_variable(tolua_S,"CliMapName",tolua_get_CliMapName,tolua_set_CliMapName);
20843 tolua_endmodule(tolua_S);
20844 return 1;
20845 }
20846
20847
20848 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
20849 TOLUA_API int luaopen_stratagus (lua_State* tolua_S) {
20850 return tolua_stratagus_open(tolua_S);
20851 };
20852 #endif
20853