← Back to branch summary

~ubuntu-branches/debian/sid/ember/sid

« back to all changes in this revision

Viewing changes to src/services/bindings/lua/lua_EmberServices.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Koch
  • Date: 2009-07-23 07:46:40 UTC
  • Revision ID: james.westby@ubuntu.com-20090723074640-wh0ukzis0kda36qv
Tags: upstream-0.5.6
Import upstream version 0.5.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/services/bindings/lua/lua_EmberServices.cpp
 
1
/*
 
2
** Lua binding: EmberServices
 
3
** Generated automatically by tolua++-1.0.92.
 
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_EmberServices_open (lua_State* tolua_S);
 
15
 
 
16
#include "required.h"
 
17
#include "services/EmberServices.h"
 
18
#include "services/logging/LoggingService.h"
 
19
#include "services/server/ServerService.h"
 
20
#include "services/config/ConfigService.h"
 
21
#include "services/metaserver/MetaserverService.h"
 
22
#include "services/scripting/ScriptingService.h"
 
23
#include "services/input/Input.h"
 
24
#include "services/input/InputService.h"
 
25
#include "services/input/IInputAdapter.h"
 
26
 
 
27
/* function to release collected object via destructor */
 
28
#ifdef __cplusplus
 
29
 
 
30
static int tolua_collect_varconf__Variable (lua_State* tolua_S)
 
31
{
 
32
 varconf::Variable* self = (varconf::Variable*) tolua_tousertype(tolua_S,1,0);
 
33
        delete self;
 
34
        return 0;
 
35
}
 
36
 
 
37
static int tolua_collect_std__vector_std__string_ (lua_State* tolua_S)
 
38
{
 
39
 std::vector<std::string>* self = (std::vector<std::string>*) tolua_tousertype(tolua_S,1,0);
 
40
        delete self;
 
41
        return 0;
 
42
}
 
43
 
 
44
static int tolua_collect_Ember__IInputAdapter (lua_State* tolua_S)
 
45
{
 
46
 Ember::IInputAdapter* self = (Ember::IInputAdapter*) tolua_tousertype(tolua_S,1,0);
 
47
        delete self;
 
48
        return 0;
 
49
}
 
50
#endif
 
51
 
 
52
 
 
53
/* function to register type */
 
54
static void tolua_reg_types (lua_State* tolua_S)
 
55
{
 
56
 tolua_usertype(tolua_S,"varconf::Variable");
 
57
 tolua_usertype(tolua_S,"Ember::EmberServices");
 
58
 tolua_usertype(tolua_S,"sigc::signal<void,const Ember::MouseMotion&,Ember::Input::InputMode>");
 
59
 tolua_usertype(tolua_S,"WFMath::Quaternion");
 
60
 tolua_usertype(tolua_S,"sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>");
 
61
 tolua_usertype(tolua_S,"Ember::IInputAdapter");
 
62
 tolua_usertype(tolua_S,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>");
 
63
 tolua_usertype(tolua_S,"Ember::ScriptingService");
 
64
 tolua_usertype(tolua_S,"std::vector<std::string>");
 
65
 tolua_usertype(tolua_S,"sigc::signal<void,const std::string&>");
 
66
 tolua_usertype(tolua_S,"Ember::IScriptingProvider");
 
67
 tolua_usertype(tolua_S,"Eris::Meta");
 
68
 tolua_usertype(tolua_S,"Ember::MouseMotion");
 
69
 tolua_usertype(tolua_S,"Ember::ServerService");
 
70
 tolua_usertype(tolua_S,"sigc::signal<void,const std::string&,const std::string&>");
 
71
 tolua_usertype(tolua_S,"Ember::InputService");
 
72
 tolua_usertype(tolua_S,"sigc::signal<void,const Atlas::Objects::Entity::RootEntity&>");
 
73
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::Account*,const std::string&>");
 
74
 tolua_usertype(tolua_S,"Ember::Input");
 
75
 tolua_usertype(tolua_S,"Eris::Entity");
 
76
 tolua_usertype(tolua_S,"WFMath::Vector<3>");
 
77
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::Connection*>");
 
78
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::Avatar*>");
 
79
 tolua_usertype(tolua_S,"Ember::MetaserverService");
 
80
 tolua_usertype(tolua_S,"SDLKey");
 
81
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::View*>");
 
82
 tolua_usertype(tolua_S,"Atlas::Message::MapType");
 
83
 tolua_usertype(tolua_S,"Ember::ConfigService");
 
84
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::Account*>");
 
85
 tolua_usertype(tolua_S,"Ember::LoggingService");
 
86
 tolua_usertype(tolua_S,"WFMath::Point<3>");
 
87
 tolua_usertype(tolua_S,"sigc::signal<void,Ember::Input::InputMode>");
 
88
}
 
89
 
 
90
/* get function: xPosition of class  Ember::MouseMotion */
 
91
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_xPosition
 
92
static int tolua_get_Ember__MouseMotion_xPosition(lua_State* tolua_S)
 
93
{
 
94
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
95
#ifndef TOLUA_RELEASE
 
96
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xPosition'",NULL);
 
97
#endif
 
98
  tolua_pushnumber(tolua_S,(lua_Number)self->xPosition);
 
99
 return 1;
 
100
}
 
101
#endif //#ifndef TOLUA_DISABLE
 
102
 
 
103
/* set function: xPosition of class  Ember::MouseMotion */
 
104
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_xPosition
 
105
static int tolua_set_Ember__MouseMotion_xPosition(lua_State* tolua_S)
 
106
{
 
107
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
108
#ifndef TOLUA_RELEASE
 
109
  tolua_Error tolua_err;
 
110
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xPosition'",NULL);
 
111
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 
112
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
113
#endif
 
114
  self->xPosition = ((int)  tolua_tonumber(tolua_S,2,0))
 
115
;
 
116
 return 0;
 
117
}
 
118
#endif //#ifndef TOLUA_DISABLE
 
119
 
 
120
/* get function: yPosition of class  Ember::MouseMotion */
 
121
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_yPosition
 
122
static int tolua_get_Ember__MouseMotion_yPosition(lua_State* tolua_S)
 
123
{
 
124
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
125
#ifndef TOLUA_RELEASE
 
126
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yPosition'",NULL);
 
127
#endif
 
128
  tolua_pushnumber(tolua_S,(lua_Number)self->yPosition);
 
129
 return 1;
 
130
}
 
131
#endif //#ifndef TOLUA_DISABLE
 
132
 
 
133
/* set function: yPosition of class  Ember::MouseMotion */
 
134
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_yPosition
 
135
static int tolua_set_Ember__MouseMotion_yPosition(lua_State* tolua_S)
 
136
{
 
137
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
138
#ifndef TOLUA_RELEASE
 
139
  tolua_Error tolua_err;
 
140
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yPosition'",NULL);
 
141
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 
142
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
143
#endif
 
144
  self->yPosition = ((int)  tolua_tonumber(tolua_S,2,0))
 
145
;
 
146
 return 0;
 
147
}
 
148
#endif //#ifndef TOLUA_DISABLE
 
149
 
 
150
/* get function: xRelativeMovement of class  Ember::MouseMotion */
 
151
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_xRelativeMovement
 
152
static int tolua_get_Ember__MouseMotion_xRelativeMovement(lua_State* tolua_S)
 
153
{
 
154
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
155
#ifndef TOLUA_RELEASE
 
156
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xRelativeMovement'",NULL);
 
157
#endif
 
158
  tolua_pushnumber(tolua_S,(lua_Number)self->xRelativeMovement);
 
159
 return 1;
 
160
}
 
161
#endif //#ifndef TOLUA_DISABLE
 
162
 
 
163
/* set function: xRelativeMovement of class  Ember::MouseMotion */
 
164
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_xRelativeMovement
 
165
static int tolua_set_Ember__MouseMotion_xRelativeMovement(lua_State* tolua_S)
 
166
{
 
167
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
168
#ifndef TOLUA_RELEASE
 
169
  tolua_Error tolua_err;
 
170
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xRelativeMovement'",NULL);
 
171
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 
172
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
173
#endif
 
174
  self->xRelativeMovement = ((float)  tolua_tonumber(tolua_S,2,0))
 
175
;
 
176
 return 0;
 
177
}
 
178
#endif //#ifndef TOLUA_DISABLE
 
179
 
 
180
/* get function: yRelativeMovement of class  Ember::MouseMotion */
 
181
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_yRelativeMovement
 
182
static int tolua_get_Ember__MouseMotion_yRelativeMovement(lua_State* tolua_S)
 
183
{
 
184
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
185
#ifndef TOLUA_RELEASE
 
186
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yRelativeMovement'",NULL);
 
187
#endif
 
188
  tolua_pushnumber(tolua_S,(lua_Number)self->yRelativeMovement);
 
189
 return 1;
 
190
}
 
191
#endif //#ifndef TOLUA_DISABLE
 
192
 
 
193
/* set function: yRelativeMovement of class  Ember::MouseMotion */
 
194
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_yRelativeMovement
 
195
static int tolua_set_Ember__MouseMotion_yRelativeMovement(lua_State* tolua_S)
 
196
{
 
197
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
198
#ifndef TOLUA_RELEASE
 
199
  tolua_Error tolua_err;
 
200
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yRelativeMovement'",NULL);
 
201
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 
202
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
203
#endif
 
204
  self->yRelativeMovement = ((float)  tolua_tonumber(tolua_S,2,0))
 
205
;
 
206
 return 0;
 
207
}
 
208
#endif //#ifndef TOLUA_DISABLE
 
209
 
 
210
/* get function: xRelativeMovementInPixels of class  Ember::MouseMotion */
 
211
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_xRelativeMovementInPixels
 
212
static int tolua_get_Ember__MouseMotion_xRelativeMovementInPixels(lua_State* tolua_S)
 
213
{
 
214
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
215
#ifndef TOLUA_RELEASE
 
216
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xRelativeMovementInPixels'",NULL);
 
217
#endif
 
218
  tolua_pushnumber(tolua_S,(lua_Number)self->xRelativeMovementInPixels);
 
219
 return 1;
 
220
}
 
221
#endif //#ifndef TOLUA_DISABLE
 
222
 
 
223
/* set function: xRelativeMovementInPixels of class  Ember::MouseMotion */
 
224
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_xRelativeMovementInPixels
 
225
static int tolua_set_Ember__MouseMotion_xRelativeMovementInPixels(lua_State* tolua_S)
 
226
{
 
227
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
228
#ifndef TOLUA_RELEASE
 
229
  tolua_Error tolua_err;
 
230
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xRelativeMovementInPixels'",NULL);
 
231
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 
232
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
233
#endif
 
234
  self->xRelativeMovementInPixels = ((int)  tolua_tonumber(tolua_S,2,0))
 
235
;
 
236
 return 0;
 
237
}
 
238
#endif //#ifndef TOLUA_DISABLE
 
239
 
 
240
/* get function: yRelativeMovementInPixels of class  Ember::MouseMotion */
 
241
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_yRelativeMovementInPixels
 
242
static int tolua_get_Ember__MouseMotion_yRelativeMovementInPixels(lua_State* tolua_S)
 
243
{
 
244
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
245
#ifndef TOLUA_RELEASE
 
246
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yRelativeMovementInPixels'",NULL);
 
247
#endif
 
248
  tolua_pushnumber(tolua_S,(lua_Number)self->yRelativeMovementInPixels);
 
249
 return 1;
 
250
}
 
251
#endif //#ifndef TOLUA_DISABLE
 
252
 
 
253
/* set function: yRelativeMovementInPixels of class  Ember::MouseMotion */
 
254
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_yRelativeMovementInPixels
 
255
static int tolua_set_Ember__MouseMotion_yRelativeMovementInPixels(lua_State* tolua_S)
 
256
{
 
257
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
258
#ifndef TOLUA_RELEASE
 
259
  tolua_Error tolua_err;
 
260
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yRelativeMovementInPixels'",NULL);
 
261
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 
262
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
263
#endif
 
264
  self->yRelativeMovementInPixels = ((int)  tolua_tonumber(tolua_S,2,0))
 
265
;
 
266
 return 0;
 
267
}
 
268
#endif //#ifndef TOLUA_DISABLE
 
269
 
 
270
/* get function: timeSinceLastMovement of class  Ember::MouseMotion */
 
271
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_timeSinceLastMovement
 
272
static int tolua_get_Ember__MouseMotion_timeSinceLastMovement(lua_State* tolua_S)
 
273
{
 
274
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
275
#ifndef TOLUA_RELEASE
 
276
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'timeSinceLastMovement'",NULL);
 
277
#endif
 
278
  tolua_pushnumber(tolua_S,(lua_Number)self->timeSinceLastMovement);
 
279
 return 1;
 
280
}
 
281
#endif //#ifndef TOLUA_DISABLE
 
282
 
 
283
/* set function: timeSinceLastMovement of class  Ember::MouseMotion */
 
284
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_timeSinceLastMovement
 
285
static int tolua_set_Ember__MouseMotion_timeSinceLastMovement(lua_State* tolua_S)
 
286
{
 
287
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
 
288
#ifndef TOLUA_RELEASE
 
289
  tolua_Error tolua_err;
 
290
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'timeSinceLastMovement'",NULL);
 
291
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 
292
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
293
#endif
 
294
  self->timeSinceLastMovement = ((float)  tolua_tonumber(tolua_S,2,0))
 
295
;
 
296
 return 0;
 
297
}
 
298
#endif //#ifndef TOLUA_DISABLE
 
299
 
 
300
/* method: getSingleton of class  Ember::Input */
 
301
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_getSingleton00
 
302
static int tolua_EmberServices_Ember_Input_getSingleton00(lua_State* tolua_S)
 
303
{
 
304
#ifndef TOLUA_RELEASE
 
305
 tolua_Error tolua_err;
 
306
 if (
 
307
     !tolua_isusertable(tolua_S,1,"Ember::Input",0,&tolua_err) ||
 
308
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
309
 )
 
310
  goto tolua_lerror;
 
311
 else
 
312
#endif
 
313
 {
 
314
  {
 
315
   Ember::Input& tolua_ret = (Ember::Input&)  Ember::Input::getSingleton();
 
316
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::Input");
 
317
  }
 
318
 }
 
319
 return 1;
 
320
#ifndef TOLUA_RELEASE
 
321
 tolua_lerror:
 
322
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 
323
 return 0;
 
324
#endif
 
325
}
 
326
#endif //#ifndef TOLUA_DISABLE
 
327
 
 
328
/* get function: EventKeyPressed of class  Ember::Input */
 
329
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventKeyPressed
 
330
static int tolua_get_Ember__Input_EventKeyPressed(lua_State* tolua_S)
 
331
{
 
332
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
333
#ifndef TOLUA_RELEASE
 
334
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventKeyPressed'",NULL);
 
335
#endif
 
336
  tolua_pushusertype(tolua_S,(void*)&self->EventKeyPressed,"sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>");
 
337
 return 1;
 
338
}
 
339
#endif //#ifndef TOLUA_DISABLE
 
340
 
 
341
/* set function: EventKeyPressed of class  Ember::Input */
 
342
#ifndef TOLUA_DISABLE_tolua_set_Ember__Input_EventKeyPressed
 
343
static int tolua_set_Ember__Input_EventKeyPressed(lua_State* tolua_S)
 
344
{
 
345
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
346
#ifndef TOLUA_RELEASE
 
347
  tolua_Error tolua_err;
 
348
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventKeyPressed'",NULL);
 
349
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>",0,&tolua_err))
 
350
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
351
#endif
 
352
  self->EventKeyPressed = *((sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>*)  tolua_tousertype(tolua_S,2,0))
 
353
;
 
354
 return 0;
 
355
}
 
356
#endif //#ifndef TOLUA_DISABLE
 
357
 
 
358
/* get function: EventKeyReleased of class  Ember::Input */
 
359
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventKeyReleased
 
360
static int tolua_get_Ember__Input_EventKeyReleased(lua_State* tolua_S)
 
361
{
 
362
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
363
#ifndef TOLUA_RELEASE
 
364
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventKeyReleased'",NULL);
 
365
#endif
 
366
  tolua_pushusertype(tolua_S,(void*)&self->EventKeyReleased,"sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>");
 
367
 return 1;
 
368
}
 
369
#endif //#ifndef TOLUA_DISABLE
 
370
 
 
371
/* set function: EventKeyReleased of class  Ember::Input */
 
372
#ifndef TOLUA_DISABLE_tolua_set_Ember__Input_EventKeyReleased
 
373
static int tolua_set_Ember__Input_EventKeyReleased(lua_State* tolua_S)
 
374
{
 
375
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
376
#ifndef TOLUA_RELEASE
 
377
  tolua_Error tolua_err;
 
378
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventKeyReleased'",NULL);
 
379
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>",0,&tolua_err))
 
380
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
381
#endif
 
382
  self->EventKeyReleased = *((sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>*)  tolua_tousertype(tolua_S,2,0))
 
383
;
 
384
 return 0;
 
385
}
 
386
#endif //#ifndef TOLUA_DISABLE
 
387
 
 
388
/* get function: EventMouseMoved of class  Ember::Input */
 
389
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventMouseMoved
 
390
static int tolua_get_Ember__Input_EventMouseMoved(lua_State* tolua_S)
 
391
{
 
392
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
393
#ifndef TOLUA_RELEASE
 
394
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMouseMoved'",NULL);
 
395
#endif
 
396
  tolua_pushusertype(tolua_S,(void*)&self->EventMouseMoved,"sigc::signal<void,const Ember::MouseMotion&,Ember::Input::InputMode>");
 
397
 return 1;
 
398
}
 
399
#endif //#ifndef TOLUA_DISABLE
 
400
 
 
401
/* set function: EventMouseMoved of class  Ember::Input */
 
402
#ifndef TOLUA_DISABLE_tolua_set_Ember__Input_EventMouseMoved
 
403
static int tolua_set_Ember__Input_EventMouseMoved(lua_State* tolua_S)
 
404
{
 
405
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
406
#ifndef TOLUA_RELEASE
 
407
  tolua_Error tolua_err;
 
408
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMouseMoved'",NULL);
 
409
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,const Ember::MouseMotion&,Ember::Input::InputMode>",0,&tolua_err))
 
410
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
411
#endif
 
412
  self->EventMouseMoved = *((sigc::signal<void,const Ember::MouseMotion&,Ember::Input::InputMode>*)  tolua_tousertype(tolua_S,2,0))
 
413
;
 
414
 return 0;
 
415
}
 
416
#endif //#ifndef TOLUA_DISABLE
 
417
 
 
418
/* get function: EventMouseButtonPressed of class  Ember::Input */
 
419
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventMouseButtonPressed
 
420
static int tolua_get_Ember__Input_EventMouseButtonPressed(lua_State* tolua_S)
 
421
{
 
422
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
423
#ifndef TOLUA_RELEASE
 
424
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMouseButtonPressed'",NULL);
 
425
#endif
 
426
  tolua_pushusertype(tolua_S,(void*)&self->EventMouseButtonPressed,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>");
 
427
 return 1;
 
428
}
 
429
#endif //#ifndef TOLUA_DISABLE
 
430
 
 
431
/* set function: EventMouseButtonPressed of class  Ember::Input */
 
432
#ifndef TOLUA_DISABLE_tolua_set_Ember__Input_EventMouseButtonPressed
 
433
static int tolua_set_Ember__Input_EventMouseButtonPressed(lua_State* tolua_S)
 
434
{
 
435
  Ember::Input* self = (Ember::Input*)  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 'EventMouseButtonPressed'",NULL);
 
439
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>",0,&tolua_err))
 
440
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
441
#endif
 
442
  self->EventMouseButtonPressed = *((sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>*)  tolua_tousertype(tolua_S,2,0))
 
443
;
 
444
 return 0;
 
445
}
 
446
#endif //#ifndef TOLUA_DISABLE
 
447
 
 
448
/* get function: EventMouseButtonReleased of class  Ember::Input */
 
449
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventMouseButtonReleased
 
450
static int tolua_get_Ember__Input_EventMouseButtonReleased(lua_State* tolua_S)
 
451
{
 
452
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
453
#ifndef TOLUA_RELEASE
 
454
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMouseButtonReleased'",NULL);
 
455
#endif
 
456
  tolua_pushusertype(tolua_S,(void*)&self->EventMouseButtonReleased,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>");
 
457
 return 1;
 
458
}
 
459
#endif //#ifndef TOLUA_DISABLE
 
460
 
 
461
/* set function: EventMouseButtonReleased of class  Ember::Input */
 
462
#ifndef TOLUA_DISABLE_tolua_set_Ember__Input_EventMouseButtonReleased
 
463
static int tolua_set_Ember__Input_EventMouseButtonReleased(lua_State* tolua_S)
 
464
{
 
465
  Ember::Input* self = (Ember::Input*)  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 'EventMouseButtonReleased'",NULL);
 
469
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>",0,&tolua_err))
 
470
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
471
#endif
 
472
  self->EventMouseButtonReleased = *((sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>*)  tolua_tousertype(tolua_S,2,0))
 
473
;
 
474
 return 0;
 
475
}
 
476
#endif //#ifndef TOLUA_DISABLE
 
477
 
 
478
/* get function: EventChangedInputMode of class  Ember::Input */
 
479
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventChangedInputMode
 
480
static int tolua_get_Ember__Input_EventChangedInputMode(lua_State* tolua_S)
 
481
{
 
482
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
483
#ifndef TOLUA_RELEASE
 
484
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventChangedInputMode'",NULL);
 
485
#endif
 
486
  tolua_pushusertype(tolua_S,(void*)&self->EventChangedInputMode,"sigc::signal<void,Ember::Input::InputMode>");
 
487
 return 1;
 
488
}
 
489
#endif //#ifndef TOLUA_DISABLE
 
490
 
 
491
/* set function: EventChangedInputMode of class  Ember::Input */
 
492
#ifndef TOLUA_DISABLE_tolua_set_Ember__Input_EventChangedInputMode
 
493
static int tolua_set_Ember__Input_EventChangedInputMode(lua_State* tolua_S)
 
494
{
 
495
  Ember::Input* self = (Ember::Input*)  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 'EventChangedInputMode'",NULL);
 
499
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Ember::Input::InputMode>",0,&tolua_err))
 
500
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
501
#endif
 
502
  self->EventChangedInputMode = *((sigc::signal<void,Ember::Input::InputMode>*)  tolua_tousertype(tolua_S,2,0))
 
503
;
 
504
 return 0;
 
505
}
 
506
#endif //#ifndef TOLUA_DISABLE
 
507
 
 
508
/* method: isKeyDown of class  Ember::Input */
 
509
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_isKeyDown00
 
510
static int tolua_EmberServices_Ember_Input_isKeyDown00(lua_State* tolua_S)
 
511
{
 
512
#ifndef TOLUA_RELEASE
 
513
 tolua_Error tolua_err;
 
514
 if (
 
515
     !tolua_isusertype(tolua_S,1,"const Ember::Input",0,&tolua_err) ||
 
516
     !tolua_isusertype(tolua_S,2,"const SDLKey",0,&tolua_err) ||
 
517
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
518
 )
 
519
  goto tolua_lerror;
 
520
 else
 
521
#endif
 
522
 {
 
523
  const Ember::Input* self = (const Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
524
  const SDLKey* tolua_var_1 = ((const SDLKey*)  tolua_tousertype(tolua_S,2,0));
 
525
#ifndef TOLUA_RELEASE
 
526
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isKeyDown'",NULL);
 
527
#endif
 
528
  {
 
529
   const bool tolua_ret = (const bool)  self->isKeyDown(*tolua_var_1);
 
530
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
531
  }
 
532
 }
 
533
 return 1;
 
534
#ifndef TOLUA_RELEASE
 
535
 tolua_lerror:
 
536
 tolua_error(tolua_S,"#ferror in function 'isKeyDown'.",&tolua_err);
 
537
 return 0;
 
538
#endif
 
539
}
 
540
#endif //#ifndef TOLUA_DISABLE
 
541
 
 
542
/* method: setInputMode of class  Ember::Input */
 
543
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_setInputMode00
 
544
static int tolua_EmberServices_Ember_Input_setInputMode00(lua_State* tolua_S)
 
545
{
 
546
#ifndef TOLUA_RELEASE
 
547
 tolua_Error tolua_err;
 
548
 if (
 
549
     !tolua_isusertype(tolua_S,1,"Ember::Input",0,&tolua_err) ||
 
550
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 
551
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
552
 )
 
553
  goto tolua_lerror;
 
554
 else
 
555
#endif
 
556
 {
 
557
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
558
  Ember::Input::InputMode mode = ((Ember::Input::InputMode) (int)  tolua_tonumber(tolua_S,2,0));
 
559
#ifndef TOLUA_RELEASE
 
560
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInputMode'",NULL);
 
561
#endif
 
562
  {
 
563
   self->setInputMode(mode);
 
564
  }
 
565
 }
 
566
 return 0;
 
567
#ifndef TOLUA_RELEASE
 
568
 tolua_lerror:
 
569
 tolua_error(tolua_S,"#ferror in function 'setInputMode'.",&tolua_err);
 
570
 return 0;
 
571
#endif
 
572
}
 
573
#endif //#ifndef TOLUA_DISABLE
 
574
 
 
575
/* method: getInputMode of class  Ember::Input */
 
576
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_getInputMode00
 
577
static int tolua_EmberServices_Ember_Input_getInputMode00(lua_State* tolua_S)
 
578
{
 
579
#ifndef TOLUA_RELEASE
 
580
 tolua_Error tolua_err;
 
581
 if (
 
582
     !tolua_isusertype(tolua_S,1,"const Ember::Input",0,&tolua_err) ||
 
583
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
584
 )
 
585
  goto tolua_lerror;
 
586
 else
 
587
#endif
 
588
 {
 
589
  const Ember::Input* self = (const Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
590
#ifndef TOLUA_RELEASE
 
591
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInputMode'",NULL);
 
592
#endif
 
593
  {
 
594
   Ember::Input::InputMode tolua_ret = (Ember::Input::InputMode)  self->getInputMode();
 
595
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
596
  }
 
597
 }
 
598
 return 1;
 
599
#ifndef TOLUA_RELEASE
 
600
 tolua_lerror:
 
601
 tolua_error(tolua_S,"#ferror in function 'getInputMode'.",&tolua_err);
 
602
 return 0;
 
603
#endif
 
604
}
 
605
#endif //#ifndef TOLUA_DISABLE
 
606
 
 
607
/* method: toggleInputMode of class  Ember::Input */
 
608
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_toggleInputMode00
 
609
static int tolua_EmberServices_Ember_Input_toggleInputMode00(lua_State* tolua_S)
 
610
{
 
611
#ifndef TOLUA_RELEASE
 
612
 tolua_Error tolua_err;
 
613
 if (
 
614
     !tolua_isusertype(tolua_S,1,"Ember::Input",0,&tolua_err) ||
 
615
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
616
 )
 
617
  goto tolua_lerror;
 
618
 else
 
619
#endif
 
620
 {
 
621
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
622
#ifndef TOLUA_RELEASE
 
623
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toggleInputMode'",NULL);
 
624
#endif
 
625
  {
 
626
   Ember::Input::InputMode tolua_ret = (Ember::Input::InputMode)  self->toggleInputMode();
 
627
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 
628
  }
 
629
 }
 
630
 return 1;
 
631
#ifndef TOLUA_RELEASE
 
632
 tolua_lerror:
 
633
 tolua_error(tolua_S,"#ferror in function 'toggleInputMode'.",&tolua_err);
 
634
 return 0;
 
635
#endif
 
636
}
 
637
#endif //#ifndef TOLUA_DISABLE
 
638
 
 
639
/* method: addAdapter of class  Ember::Input */
 
640
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_addAdapter00
 
641
static int tolua_EmberServices_Ember_Input_addAdapter00(lua_State* tolua_S)
 
642
{
 
643
#ifndef TOLUA_RELEASE
 
644
 tolua_Error tolua_err;
 
645
 if (
 
646
     !tolua_isusertype(tolua_S,1,"Ember::Input",0,&tolua_err) ||
 
647
     !tolua_isusertype(tolua_S,2,"Ember::IInputAdapter",0,&tolua_err) ||
 
648
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
649
 )
 
650
  goto tolua_lerror;
 
651
 else
 
652
#endif
 
653
 {
 
654
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
655
  Ember::IInputAdapter* adapter = ((Ember::IInputAdapter*)  tolua_tousertype(tolua_S,2,0));
 
656
#ifndef TOLUA_RELEASE
 
657
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addAdapter'",NULL);
 
658
#endif
 
659
  {
 
660
   self->addAdapter(adapter);
 
661
  }
 
662
 }
 
663
 return 0;
 
664
#ifndef TOLUA_RELEASE
 
665
 tolua_lerror:
 
666
 tolua_error(tolua_S,"#ferror in function 'addAdapter'.",&tolua_err);
 
667
 return 0;
 
668
#endif
 
669
}
 
670
#endif //#ifndef TOLUA_DISABLE
 
671
 
 
672
/* method: removeAdapter of class  Ember::Input */
 
673
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_removeAdapter00
 
674
static int tolua_EmberServices_Ember_Input_removeAdapter00(lua_State* tolua_S)
 
675
{
 
676
#ifndef TOLUA_RELEASE
 
677
 tolua_Error tolua_err;
 
678
 if (
 
679
     !tolua_isusertype(tolua_S,1,"Ember::Input",0,&tolua_err) ||
 
680
     !tolua_isusertype(tolua_S,2,"Ember::IInputAdapter",0,&tolua_err) ||
 
681
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
682
 )
 
683
  goto tolua_lerror;
 
684
 else
 
685
#endif
 
686
 {
 
687
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
 
688
  Ember::IInputAdapter* adapter = ((Ember::IInputAdapter*)  tolua_tousertype(tolua_S,2,0));
 
689
#ifndef TOLUA_RELEASE
 
690
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeAdapter'",NULL);
 
691
#endif
 
692
  {
 
693
   self->removeAdapter(adapter);
 
694
  }
 
695
 }
 
696
 return 0;
 
697
#ifndef TOLUA_RELEASE
 
698
 tolua_lerror:
 
699
 tolua_error(tolua_S,"#ferror in function 'removeAdapter'.",&tolua_err);
 
700
 return 0;
 
701
#endif
 
702
}
 
703
#endif //#ifndef TOLUA_DISABLE
 
704
 
 
705
/* get function: SETVALUE of class  Ember::ConfigService */
 
706
#ifndef TOLUA_DISABLE_tolua_get_Ember__ConfigService_SETVALUE
 
707
static int tolua_get_Ember__ConfigService_SETVALUE(lua_State* tolua_S)
 
708
{
 
709
  tolua_pushcppstring(tolua_S,(const char*)Ember::ConfigService::SETVALUE);
 
710
 return 1;
 
711
}
 
712
#endif //#ifndef TOLUA_DISABLE
 
713
 
 
714
/* get function: GETVALUE of class  Ember::ConfigService */
 
715
#ifndef TOLUA_DISABLE_tolua_get_Ember__ConfigService_GETVALUE
 
716
static int tolua_get_Ember__ConfigService_GETVALUE(lua_State* tolua_S)
 
717
{
 
718
  tolua_pushcppstring(tolua_S,(const char*)Ember::ConfigService::GETVALUE);
 
719
 return 1;
 
720
}
 
721
#endif //#ifndef TOLUA_DISABLE
 
722
 
 
723
/* method: getValue of class  Ember::ConfigService */
 
724
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getValue00
 
725
static int tolua_EmberServices_Ember_ConfigService_getValue00(lua_State* tolua_S)
 
726
{
 
727
#ifndef TOLUA_RELEASE
 
728
 tolua_Error tolua_err;
 
729
 if (
 
730
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
731
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
732
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
 
733
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
734
 )
 
735
  goto tolua_lerror;
 
736
 else
 
737
#endif
 
738
 {
 
739
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
740
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
741
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
 
742
#ifndef TOLUA_RELEASE
 
743
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'",NULL);
 
744
#endif
 
745
  {
 
746
   varconf::Variable tolua_ret = (varconf::Variable)  self->getValue(section,key);
 
747
   {
 
748
#ifdef __cplusplus
 
749
    void* tolua_obj = new varconf::Variable(tolua_ret);
 
750
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"varconf::Variable");
 
751
#else
 
752
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(varconf::Variable));
 
753
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"varconf::Variable");
 
754
#endif
 
755
   }
 
756
   tolua_pushcppstring(tolua_S,(const char*)section);
 
757
   tolua_pushcppstring(tolua_S,(const char*)key);
 
758
  }
 
759
 }
 
760
 return 3;
 
761
#ifndef TOLUA_RELEASE
 
762
 tolua_lerror:
 
763
 tolua_error(tolua_S,"#ferror in function 'getValue'.",&tolua_err);
 
764
 return 0;
 
765
#endif
 
766
}
 
767
#endif //#ifndef TOLUA_DISABLE
 
768
 
 
769
/* method: setValue of class  Ember::ConfigService */
 
770
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_setValue00
 
771
static int tolua_EmberServices_Ember_ConfigService_setValue00(lua_State* tolua_S)
 
772
{
 
773
#ifndef TOLUA_RELEASE
 
774
 tolua_Error tolua_err;
 
775
 if (
 
776
     !tolua_isusertype(tolua_S,1,"Ember::ConfigService",0,&tolua_err) ||
 
777
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
778
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
 
779
     !tolua_isusertype(tolua_S,4,"const varconf::Variable",0,&tolua_err) ||
 
780
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 
781
 )
 
782
  goto tolua_lerror;
 
783
 else
 
784
#endif
 
785
 {
 
786
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
787
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
788
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
 
789
  const varconf::Variable* value = ((const varconf::Variable*)  tolua_tousertype(tolua_S,4,0));
 
790
#ifndef TOLUA_RELEASE
 
791
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'",NULL);
 
792
#endif
 
793
  {
 
794
   self->setValue(section,key,*value);
 
795
   tolua_pushcppstring(tolua_S,(const char*)section);
 
796
   tolua_pushcppstring(tolua_S,(const char*)key);
 
797
  }
 
798
 }
 
799
 return 2;
 
800
#ifndef TOLUA_RELEASE
 
801
 tolua_lerror:
 
802
 tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
 
803
 return 0;
 
804
#endif
 
805
}
 
806
#endif //#ifndef TOLUA_DISABLE
 
807
 
 
808
/* method: isItemSet of class  Ember::ConfigService */
 
809
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_isItemSet00
 
810
static int tolua_EmberServices_Ember_ConfigService_isItemSet00(lua_State* tolua_S)
 
811
{
 
812
#ifndef TOLUA_RELEASE
 
813
 tolua_Error tolua_err;
 
814
 if (
 
815
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
816
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
817
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
 
818
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
 
819
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 
820
 )
 
821
  goto tolua_lerror;
 
822
 else
 
823
#endif
 
824
 {
 
825
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
826
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
827
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
 
828
  const std::string value = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
 
829
#ifndef TOLUA_RELEASE
 
830
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isItemSet'",NULL);
 
831
#endif
 
832
  {
 
833
   bool tolua_ret = (bool)  self->isItemSet(section,key,value);
 
834
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
835
   tolua_pushcppstring(tolua_S,(const char*)section);
 
836
   tolua_pushcppstring(tolua_S,(const char*)key);
 
837
   tolua_pushcppstring(tolua_S,(const char*)value);
 
838
  }
 
839
 }
 
840
 return 4;
 
841
#ifndef TOLUA_RELEASE
 
842
 tolua_lerror:
 
843
 tolua_error(tolua_S,"#ferror in function 'isItemSet'.",&tolua_err);
 
844
 return 0;
 
845
#endif
 
846
}
 
847
#endif //#ifndef TOLUA_DISABLE
 
848
 
 
849
/* method: itemExists of class  Ember::ConfigService */
 
850
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_itemExists00
 
851
static int tolua_EmberServices_Ember_ConfigService_itemExists00(lua_State* tolua_S)
 
852
{
 
853
#ifndef TOLUA_RELEASE
 
854
 tolua_Error tolua_err;
 
855
 if (
 
856
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
857
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
858
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
 
859
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
860
 )
 
861
  goto tolua_lerror;
 
862
 else
 
863
#endif
 
864
 {
 
865
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
866
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
867
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
 
868
#ifndef TOLUA_RELEASE
 
869
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'itemExists'",NULL);
 
870
#endif
 
871
  {
 
872
   bool tolua_ret = (bool)  self->itemExists(section,key);
 
873
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
874
   tolua_pushcppstring(tolua_S,(const char*)section);
 
875
   tolua_pushcppstring(tolua_S,(const char*)key);
 
876
  }
 
877
 }
 
878
 return 3;
 
879
#ifndef TOLUA_RELEASE
 
880
 tolua_lerror:
 
881
 tolua_error(tolua_S,"#ferror in function 'itemExists'.",&tolua_err);
 
882
 return 0;
 
883
#endif
 
884
}
 
885
#endif //#ifndef TOLUA_DISABLE
 
886
 
 
887
/* method: deleteItem of class  Ember::ConfigService */
 
888
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_deleteItem00
 
889
static int tolua_EmberServices_Ember_ConfigService_deleteItem00(lua_State* tolua_S)
 
890
{
 
891
#ifndef TOLUA_RELEASE
 
892
 tolua_Error tolua_err;
 
893
 if (
 
894
     !tolua_isusertype(tolua_S,1,"Ember::ConfigService",0,&tolua_err) ||
 
895
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
896
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
 
897
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
898
 )
 
899
  goto tolua_lerror;
 
900
 else
 
901
#endif
 
902
 {
 
903
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
904
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
905
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
 
906
#ifndef TOLUA_RELEASE
 
907
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'deleteItem'",NULL);
 
908
#endif
 
909
  {
 
910
   bool tolua_ret = (bool)  self->deleteItem(section,key);
 
911
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
912
   tolua_pushcppstring(tolua_S,(const char*)section);
 
913
   tolua_pushcppstring(tolua_S,(const char*)key);
 
914
  }
 
915
 }
 
916
 return 3;
 
917
#ifndef TOLUA_RELEASE
 
918
 tolua_lerror:
 
919
 tolua_error(tolua_S,"#ferror in function 'deleteItem'.",&tolua_err);
 
920
 return 0;
 
921
#endif
 
922
}
 
923
#endif //#ifndef TOLUA_DISABLE
 
924
 
 
925
/* method: loadSavedConfig of class  Ember::ConfigService */
 
926
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_loadSavedConfig00
 
927
static int tolua_EmberServices_Ember_ConfigService_loadSavedConfig00(lua_State* tolua_S)
 
928
{
 
929
#ifndef TOLUA_RELEASE
 
930
 tolua_Error tolua_err;
 
931
 if (
 
932
     !tolua_isusertype(tolua_S,1,"Ember::ConfigService",0,&tolua_err) ||
 
933
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
934
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
935
 )
 
936
  goto tolua_lerror;
 
937
 else
 
938
#endif
 
939
 {
 
940
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
941
  const std::string filename = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
942
#ifndef TOLUA_RELEASE
 
943
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadSavedConfig'",NULL);
 
944
#endif
 
945
  {
 
946
   bool tolua_ret = (bool)  self->loadSavedConfig(filename);
 
947
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
948
   tolua_pushcppstring(tolua_S,(const char*)filename);
 
949
  }
 
950
 }
 
951
 return 2;
 
952
#ifndef TOLUA_RELEASE
 
953
 tolua_lerror:
 
954
 tolua_error(tolua_S,"#ferror in function 'loadSavedConfig'.",&tolua_err);
 
955
 return 0;
 
956
#endif
 
957
}
 
958
#endif //#ifndef TOLUA_DISABLE
 
959
 
 
960
/* method: saveConfig of class  Ember::ConfigService */
 
961
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_saveConfig00
 
962
static int tolua_EmberServices_Ember_ConfigService_saveConfig00(lua_State* tolua_S)
 
963
{
 
964
#ifndef TOLUA_RELEASE
 
965
 tolua_Error tolua_err;
 
966
 if (
 
967
     !tolua_isusertype(tolua_S,1,"Ember::ConfigService",0,&tolua_err) ||
 
968
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
969
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
970
 )
 
971
  goto tolua_lerror;
 
972
 else
 
973
#endif
 
974
 {
 
975
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
976
  const std::string filename = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
977
#ifndef TOLUA_RELEASE
 
978
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saveConfig'",NULL);
 
979
#endif
 
980
  {
 
981
   bool tolua_ret = (bool)  self->saveConfig(filename);
 
982
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
983
   tolua_pushcppstring(tolua_S,(const char*)filename);
 
984
  }
 
985
 }
 
986
 return 2;
 
987
#ifndef TOLUA_RELEASE
 
988
 tolua_lerror:
 
989
 tolua_error(tolua_S,"#ferror in function 'saveConfig'.",&tolua_err);
 
990
 return 0;
 
991
#endif
 
992
}
 
993
#endif //#ifndef TOLUA_DISABLE
 
994
 
 
995
/* method: getHomeDirectory of class  Ember::ConfigService */
 
996
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getHomeDirectory00
 
997
static int tolua_EmberServices_Ember_ConfigService_getHomeDirectory00(lua_State* tolua_S)
 
998
{
 
999
#ifndef TOLUA_RELEASE
 
1000
 tolua_Error tolua_err;
 
1001
 if (
 
1002
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
1003
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1004
 )
 
1005
  goto tolua_lerror;
 
1006
 else
 
1007
#endif
 
1008
 {
 
1009
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
1010
#ifndef TOLUA_RELEASE
 
1011
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHomeDirectory'",NULL);
 
1012
#endif
 
1013
  {
 
1014
   const std::string tolua_ret = (const std::string)  self->getHomeDirectory();
 
1015
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1016
  }
 
1017
 }
 
1018
 return 1;
 
1019
#ifndef TOLUA_RELEASE
 
1020
 tolua_lerror:
 
1021
 tolua_error(tolua_S,"#ferror in function 'getHomeDirectory'.",&tolua_err);
 
1022
 return 0;
 
1023
#endif
 
1024
}
 
1025
#endif //#ifndef TOLUA_DISABLE
 
1026
 
 
1027
/* method: getSharedDataDirectory of class  Ember::ConfigService */
 
1028
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getSharedDataDirectory00
 
1029
static int tolua_EmberServices_Ember_ConfigService_getSharedDataDirectory00(lua_State* tolua_S)
 
1030
{
 
1031
#ifndef TOLUA_RELEASE
 
1032
 tolua_Error tolua_err;
 
1033
 if (
 
1034
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
1035
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1036
 )
 
1037
  goto tolua_lerror;
 
1038
 else
 
1039
#endif
 
1040
 {
 
1041
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
1042
#ifndef TOLUA_RELEASE
 
1043
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSharedDataDirectory'",NULL);
 
1044
#endif
 
1045
  {
 
1046
   const std::string tolua_ret = (const std::string)  self->getSharedDataDirectory();
 
1047
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1048
  }
 
1049
 }
 
1050
 return 1;
 
1051
#ifndef TOLUA_RELEASE
 
1052
 tolua_lerror:
 
1053
 tolua_error(tolua_S,"#ferror in function 'getSharedDataDirectory'.",&tolua_err);
 
1054
 return 0;
 
1055
#endif
 
1056
}
 
1057
#endif //#ifndef TOLUA_DISABLE
 
1058
 
 
1059
/* method: getEmberDataDirectory of class  Ember::ConfigService */
 
1060
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getEmberDataDirectory00
 
1061
static int tolua_EmberServices_Ember_ConfigService_getEmberDataDirectory00(lua_State* tolua_S)
 
1062
{
 
1063
#ifndef TOLUA_RELEASE
 
1064
 tolua_Error tolua_err;
 
1065
 if (
 
1066
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
1067
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1068
 )
 
1069
  goto tolua_lerror;
 
1070
 else
 
1071
#endif
 
1072
 {
 
1073
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
1074
#ifndef TOLUA_RELEASE
 
1075
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEmberDataDirectory'",NULL);
 
1076
#endif
 
1077
  {
 
1078
   const std::string tolua_ret = (const std::string)  self->getEmberDataDirectory();
 
1079
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1080
  }
 
1081
 }
 
1082
 return 1;
 
1083
#ifndef TOLUA_RELEASE
 
1084
 tolua_lerror:
 
1085
 tolua_error(tolua_S,"#ferror in function 'getEmberDataDirectory'.",&tolua_err);
 
1086
 return 0;
 
1087
#endif
 
1088
}
 
1089
#endif //#ifndef TOLUA_DISABLE
 
1090
 
 
1091
/* method: getEmberMediaDirectory of class  Ember::ConfigService */
 
1092
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getEmberMediaDirectory00
 
1093
static int tolua_EmberServices_Ember_ConfigService_getEmberMediaDirectory00(lua_State* tolua_S)
 
1094
{
 
1095
#ifndef TOLUA_RELEASE
 
1096
 tolua_Error tolua_err;
 
1097
 if (
 
1098
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
1099
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1100
 )
 
1101
  goto tolua_lerror;
 
1102
 else
 
1103
#endif
 
1104
 {
 
1105
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
1106
#ifndef TOLUA_RELEASE
 
1107
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEmberMediaDirectory'",NULL);
 
1108
#endif
 
1109
  {
 
1110
   const std::string tolua_ret = (const std::string)  self->getEmberMediaDirectory();
 
1111
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1112
  }
 
1113
 }
 
1114
 return 1;
 
1115
#ifndef TOLUA_RELEASE
 
1116
 tolua_lerror:
 
1117
 tolua_error(tolua_S,"#ferror in function 'getEmberMediaDirectory'.",&tolua_err);
 
1118
 return 0;
 
1119
#endif
 
1120
}
 
1121
#endif //#ifndef TOLUA_DISABLE
 
1122
 
 
1123
/* method: getUserMediaDirectory of class  Ember::ConfigService */
 
1124
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getUserMediaDirectory00
 
1125
static int tolua_EmberServices_Ember_ConfigService_getUserMediaDirectory00(lua_State* tolua_S)
 
1126
{
 
1127
#ifndef TOLUA_RELEASE
 
1128
 tolua_Error tolua_err;
 
1129
 if (
 
1130
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
1131
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1132
 )
 
1133
  goto tolua_lerror;
 
1134
 else
 
1135
#endif
 
1136
 {
 
1137
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
1138
#ifndef TOLUA_RELEASE
 
1139
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUserMediaDirectory'",NULL);
 
1140
#endif
 
1141
  {
 
1142
   const std::string tolua_ret = (const std::string)  self->getUserMediaDirectory();
 
1143
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1144
  }
 
1145
 }
 
1146
 return 1;
 
1147
#ifndef TOLUA_RELEASE
 
1148
 tolua_lerror:
 
1149
 tolua_error(tolua_S,"#ferror in function 'getUserMediaDirectory'.",&tolua_err);
 
1150
 return 0;
 
1151
#endif
 
1152
}
 
1153
#endif //#ifndef TOLUA_DISABLE
 
1154
 
 
1155
/* method: getSharedMediaDirectory of class  Ember::ConfigService */
 
1156
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getSharedMediaDirectory00
 
1157
static int tolua_EmberServices_Ember_ConfigService_getSharedMediaDirectory00(lua_State* tolua_S)
 
1158
{
 
1159
#ifndef TOLUA_RELEASE
 
1160
 tolua_Error tolua_err;
 
1161
 if (
 
1162
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
1163
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1164
 )
 
1165
  goto tolua_lerror;
 
1166
 else
 
1167
#endif
 
1168
 {
 
1169
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
1170
#ifndef TOLUA_RELEASE
 
1171
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSharedMediaDirectory'",NULL);
 
1172
#endif
 
1173
  {
 
1174
   const std::string tolua_ret = (const std::string)  self->getSharedMediaDirectory();
 
1175
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1176
  }
 
1177
 }
 
1178
 return 1;
 
1179
#ifndef TOLUA_RELEASE
 
1180
 tolua_lerror:
 
1181
 tolua_error(tolua_S,"#ferror in function 'getSharedMediaDirectory'.",&tolua_err);
 
1182
 return 0;
 
1183
#endif
 
1184
}
 
1185
#endif //#ifndef TOLUA_DISABLE
 
1186
 
 
1187
/* method: getSharedConfigDirectory of class  Ember::ConfigService */
 
1188
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getSharedConfigDirectory00
 
1189
static int tolua_EmberServices_Ember_ConfigService_getSharedConfigDirectory00(lua_State* tolua_S)
 
1190
{
 
1191
#ifndef TOLUA_RELEASE
 
1192
 tolua_Error tolua_err;
 
1193
 if (
 
1194
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
 
1195
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1196
 )
 
1197
  goto tolua_lerror;
 
1198
 else
 
1199
#endif
 
1200
 {
 
1201
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
1202
#ifndef TOLUA_RELEASE
 
1203
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSharedConfigDirectory'",NULL);
 
1204
#endif
 
1205
  {
 
1206
   const std::string tolua_ret = (const std::string)  self->getSharedConfigDirectory();
 
1207
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 
1208
  }
 
1209
 }
 
1210
 return 1;
 
1211
#ifndef TOLUA_RELEASE
 
1212
 tolua_lerror:
 
1213
 tolua_error(tolua_S,"#ferror in function 'getSharedConfigDirectory'.",&tolua_err);
 
1214
 return 0;
 
1215
#endif
 
1216
}
 
1217
#endif //#ifndef TOLUA_DISABLE
 
1218
 
 
1219
/* get function: EventChangedConfigItem of class  Ember::ConfigService */
 
1220
#ifndef TOLUA_DISABLE_tolua_get_Ember__ConfigService_EventChangedConfigItem
 
1221
static int tolua_get_Ember__ConfigService_EventChangedConfigItem(lua_State* tolua_S)
 
1222
{
 
1223
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
1224
#ifndef TOLUA_RELEASE
 
1225
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventChangedConfigItem'",NULL);
 
1226
#endif
 
1227
  tolua_pushusertype(tolua_S,(void*)&self->EventChangedConfigItem,"sigc::signal<void,const std::string&,const std::string&>");
 
1228
 return 1;
 
1229
}
 
1230
#endif //#ifndef TOLUA_DISABLE
 
1231
 
 
1232
/* set function: EventChangedConfigItem of class  Ember::ConfigService */
 
1233
#ifndef TOLUA_DISABLE_tolua_set_Ember__ConfigService_EventChangedConfigItem
 
1234
static int tolua_set_Ember__ConfigService_EventChangedConfigItem(lua_State* tolua_S)
 
1235
{
 
1236
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
 
1237
#ifndef TOLUA_RELEASE
 
1238
  tolua_Error tolua_err;
 
1239
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventChangedConfigItem'",NULL);
 
1240
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,const std::string&,const std::string&>",0,&tolua_err))
 
1241
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
1242
#endif
 
1243
  self->EventChangedConfigItem = *((sigc::signal<void,const std::string&,const std::string&>*)  tolua_tousertype(tolua_S,2,0))
 
1244
;
 
1245
 return 0;
 
1246
}
 
1247
#endif //#ifndef TOLUA_DISABLE
 
1248
 
 
1249
/* method: getMetaServer of class  Ember::MetaserverService */
 
1250
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_MetaserverService_getMetaServer00
 
1251
static int tolua_EmberServices_Ember_MetaserverService_getMetaServer00(lua_State* tolua_S)
 
1252
{
 
1253
#ifndef TOLUA_RELEASE
 
1254
 tolua_Error tolua_err;
 
1255
 if (
 
1256
     !tolua_isusertype(tolua_S,1,"const Ember::MetaserverService",0,&tolua_err) ||
 
1257
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1258
 )
 
1259
  goto tolua_lerror;
 
1260
 else
 
1261
#endif
 
1262
 {
 
1263
  const Ember::MetaserverService* self = (const Ember::MetaserverService*)  tolua_tousertype(tolua_S,1,0);
 
1264
#ifndef TOLUA_RELEASE
 
1265
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMetaServer'",NULL);
 
1266
#endif
 
1267
  {
 
1268
   Eris::Meta& tolua_ret = (Eris::Meta&)  self->getMetaServer();
 
1269
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Eris::Meta");
 
1270
  }
 
1271
 }
 
1272
 return 1;
 
1273
#ifndef TOLUA_RELEASE
 
1274
 tolua_lerror:
 
1275
 tolua_error(tolua_S,"#ferror in function 'getMetaServer'.",&tolua_err);
 
1276
 return 0;
 
1277
#endif
 
1278
}
 
1279
#endif //#ifndef TOLUA_DISABLE
 
1280
 
 
1281
/* method: isConnected of class  Ember::ServerService */
 
1282
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_isConnected00
 
1283
static int tolua_EmberServices_Ember_ServerService_isConnected00(lua_State* tolua_S)
 
1284
{
 
1285
#ifndef TOLUA_RELEASE
 
1286
 tolua_Error tolua_err;
 
1287
 if (
 
1288
     !tolua_isusertype(tolua_S,1,"const Ember::ServerService",0,&tolua_err) ||
 
1289
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1290
 )
 
1291
  goto tolua_lerror;
 
1292
 else
 
1293
#endif
 
1294
 {
 
1295
  const Ember::ServerService* self = (const Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1296
#ifndef TOLUA_RELEASE
 
1297
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isConnected'",NULL);
 
1298
#endif
 
1299
  {
 
1300
   bool tolua_ret = (bool)  self->isConnected();
 
1301
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1302
  }
 
1303
 }
 
1304
 return 1;
 
1305
#ifndef TOLUA_RELEASE
 
1306
 tolua_lerror:
 
1307
 tolua_error(tolua_S,"#ferror in function 'isConnected'.",&tolua_err);
 
1308
 return 0;
 
1309
#endif
 
1310
}
 
1311
#endif //#ifndef TOLUA_DISABLE
 
1312
 
 
1313
/* method: connect of class  Ember::ServerService */
 
1314
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_connect00
 
1315
static int tolua_EmberServices_Ember_ServerService_connect00(lua_State* tolua_S)
 
1316
{
 
1317
#ifndef TOLUA_RELEASE
 
1318
 tolua_Error tolua_err;
 
1319
 if (
 
1320
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1321
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
1322
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 
1323
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
1324
 )
 
1325
  goto tolua_lerror;
 
1326
 else
 
1327
#endif
 
1328
 {
 
1329
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1330
  const std::string host = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
1331
  short port = ((short)  tolua_tonumber(tolua_S,3,6767));
 
1332
#ifndef TOLUA_RELEASE
 
1333
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'connect'",NULL);
 
1334
#endif
 
1335
  {
 
1336
   bool tolua_ret = (bool)  self->connect(host,port);
 
1337
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1338
   tolua_pushcppstring(tolua_S,(const char*)host);
 
1339
  }
 
1340
 }
 
1341
 return 2;
 
1342
#ifndef TOLUA_RELEASE
 
1343
 tolua_lerror:
 
1344
 tolua_error(tolua_S,"#ferror in function 'connect'.",&tolua_err);
 
1345
 return 0;
 
1346
#endif
 
1347
}
 
1348
#endif //#ifndef TOLUA_DISABLE
 
1349
 
 
1350
/* method: disconnect of class  Ember::ServerService */
 
1351
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_disconnect00
 
1352
static int tolua_EmberServices_Ember_ServerService_disconnect00(lua_State* tolua_S)
 
1353
{
 
1354
#ifndef TOLUA_RELEASE
 
1355
 tolua_Error tolua_err;
 
1356
 if (
 
1357
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1358
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1359
 )
 
1360
  goto tolua_lerror;
 
1361
 else
 
1362
#endif
 
1363
 {
 
1364
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1365
#ifndef TOLUA_RELEASE
 
1366
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'disconnect'",NULL);
 
1367
#endif
 
1368
  {
 
1369
   self->disconnect();
 
1370
  }
 
1371
 }
 
1372
 return 0;
 
1373
#ifndef TOLUA_RELEASE
 
1374
 tolua_lerror:
 
1375
 tolua_error(tolua_S,"#ferror in function 'disconnect'.",&tolua_err);
 
1376
 return 0;
 
1377
#endif
 
1378
}
 
1379
#endif //#ifndef TOLUA_DISABLE
 
1380
 
 
1381
/* method: takeCharacter of class  Ember::ServerService */
 
1382
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_takeCharacter00
 
1383
static int tolua_EmberServices_Ember_ServerService_takeCharacter00(lua_State* tolua_S)
 
1384
{
 
1385
#ifndef TOLUA_RELEASE
 
1386
 tolua_Error tolua_err;
 
1387
 if (
 
1388
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1389
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
1390
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1391
 )
 
1392
  goto tolua_lerror;
 
1393
 else
 
1394
#endif
 
1395
 {
 
1396
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1397
  const std::string id = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
1398
#ifndef TOLUA_RELEASE
 
1399
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'takeCharacter'",NULL);
 
1400
#endif
 
1401
  {
 
1402
   self->takeCharacter(id);
 
1403
   tolua_pushcppstring(tolua_S,(const char*)id);
 
1404
  }
 
1405
 }
 
1406
 return 1;
 
1407
#ifndef TOLUA_RELEASE
 
1408
 tolua_lerror:
 
1409
 tolua_error(tolua_S,"#ferror in function 'takeCharacter'.",&tolua_err);
 
1410
 return 0;
 
1411
#endif
 
1412
}
 
1413
#endif //#ifndef TOLUA_DISABLE
 
1414
 
 
1415
/* method: createCharacter of class  Ember::ServerService */
 
1416
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_createCharacter00
 
1417
static int tolua_EmberServices_Ember_ServerService_createCharacter00(lua_State* tolua_S)
 
1418
{
 
1419
#ifndef TOLUA_RELEASE
 
1420
 tolua_Error tolua_err;
 
1421
 if (
 
1422
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1423
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
1424
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
 
1425
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
 
1426
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
 
1427
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 
1428
 )
 
1429
  goto tolua_lerror;
 
1430
 else
 
1431
#endif
 
1432
 {
 
1433
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1434
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
1435
  const std::string sex = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
 
1436
  const std::string type = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
 
1437
  const std::string description = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
 
1438
#ifndef TOLUA_RELEASE
 
1439
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCharacter'",NULL);
 
1440
#endif
 
1441
  {
 
1442
   bool tolua_ret = (bool)  self->createCharacter(name,sex,type,description);
 
1443
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
1444
   tolua_pushcppstring(tolua_S,(const char*)name);
 
1445
   tolua_pushcppstring(tolua_S,(const char*)sex);
 
1446
   tolua_pushcppstring(tolua_S,(const char*)type);
 
1447
   tolua_pushcppstring(tolua_S,(const char*)description);
 
1448
  }
 
1449
 }
 
1450
 return 5;
 
1451
#ifndef TOLUA_RELEASE
 
1452
 tolua_lerror:
 
1453
 tolua_error(tolua_S,"#ferror in function 'createCharacter'.",&tolua_err);
 
1454
 return 0;
 
1455
#endif
 
1456
}
 
1457
#endif //#ifndef TOLUA_DISABLE
 
1458
 
 
1459
/* method: moveToPoint of class  Ember::ServerService */
 
1460
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_moveToPoint00
 
1461
static int tolua_EmberServices_Ember_ServerService_moveToPoint00(lua_State* tolua_S)
 
1462
{
 
1463
#ifndef TOLUA_RELEASE
 
1464
 tolua_Error tolua_err;
 
1465
 if (
 
1466
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1467
     !tolua_isusertype(tolua_S,2,"const WFMath::Point<3>",0,&tolua_err) ||
 
1468
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1469
 )
 
1470
  goto tolua_lerror;
 
1471
 else
 
1472
#endif
 
1473
 {
 
1474
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1475
  const WFMath::Point<3>* dest = ((const WFMath::Point<3>*)  tolua_tousertype(tolua_S,2,0));
 
1476
#ifndef TOLUA_RELEASE
 
1477
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveToPoint'",NULL);
 
1478
#endif
 
1479
  {
 
1480
   self->moveToPoint(*dest);
 
1481
  }
 
1482
 }
 
1483
 return 0;
 
1484
#ifndef TOLUA_RELEASE
 
1485
 tolua_lerror:
 
1486
 tolua_error(tolua_S,"#ferror in function 'moveToPoint'.",&tolua_err);
 
1487
 return 0;
 
1488
#endif
 
1489
}
 
1490
#endif //#ifndef TOLUA_DISABLE
 
1491
 
 
1492
/* method: moveInDirection of class  Ember::ServerService */
 
1493
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_moveInDirection00
 
1494
static int tolua_EmberServices_Ember_ServerService_moveInDirection00(lua_State* tolua_S)
 
1495
{
 
1496
#ifndef TOLUA_RELEASE
 
1497
 tolua_Error tolua_err;
 
1498
 if (
 
1499
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1500
     !tolua_isusertype(tolua_S,2,"const WFMath::Vector<3>",0,&tolua_err) ||
 
1501
     !tolua_isusertype(tolua_S,3,"const WFMath::Quaternion",0,&tolua_err) ||
 
1502
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
1503
 )
 
1504
  goto tolua_lerror;
 
1505
 else
 
1506
#endif
 
1507
 {
 
1508
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1509
  const WFMath::Vector<3>* velocity = ((const WFMath::Vector<3>*)  tolua_tousertype(tolua_S,2,0));
 
1510
  const WFMath::Quaternion* orientation = ((const WFMath::Quaternion*)  tolua_tousertype(tolua_S,3,0));
 
1511
#ifndef TOLUA_RELEASE
 
1512
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveInDirection'",NULL);
 
1513
#endif
 
1514
  {
 
1515
   self->moveInDirection(*velocity,*orientation);
 
1516
  }
 
1517
 }
 
1518
 return 0;
 
1519
#ifndef TOLUA_RELEASE
 
1520
 tolua_lerror:
 
1521
 tolua_error(tolua_S,"#ferror in function 'moveInDirection'.",&tolua_err);
 
1522
 return 0;
 
1523
#endif
 
1524
}
 
1525
#endif //#ifndef TOLUA_DISABLE
 
1526
 
 
1527
/* method: moveInDirection of class  Ember::ServerService */
 
1528
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_moveInDirection01
 
1529
static int tolua_EmberServices_Ember_ServerService_moveInDirection01(lua_State* tolua_S)
 
1530
{
 
1531
 tolua_Error tolua_err;
 
1532
 if (
 
1533
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1534
     !tolua_isusertype(tolua_S,2,"const WFMath::Vector<3>",0,&tolua_err) ||
 
1535
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1536
 )
 
1537
  goto tolua_lerror;
 
1538
 else
 
1539
 {
 
1540
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1541
  const WFMath::Vector<3>* velocity = ((const WFMath::Vector<3>*)  tolua_tousertype(tolua_S,2,0));
 
1542
#ifndef TOLUA_RELEASE
 
1543
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveInDirection'",NULL);
 
1544
#endif
 
1545
  {
 
1546
   self->moveInDirection(*velocity);
 
1547
  }
 
1548
 }
 
1549
 return 0;
 
1550
tolua_lerror:
 
1551
 return tolua_EmberServices_Ember_ServerService_moveInDirection00(tolua_S);
 
1552
}
 
1553
#endif //#ifndef TOLUA_DISABLE
 
1554
 
 
1555
/* method: say of class  Ember::ServerService */
 
1556
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_say00
 
1557
static int tolua_EmberServices_Ember_ServerService_say00(lua_State* tolua_S)
 
1558
{
 
1559
#ifndef TOLUA_RELEASE
 
1560
 tolua_Error tolua_err;
 
1561
 if (
 
1562
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1563
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
1564
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1565
 )
 
1566
  goto tolua_lerror;
 
1567
 else
 
1568
#endif
 
1569
 {
 
1570
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1571
  const std::string message = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
1572
#ifndef TOLUA_RELEASE
 
1573
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'say'",NULL);
 
1574
#endif
 
1575
  {
 
1576
   self->say(message);
 
1577
   tolua_pushcppstring(tolua_S,(const char*)message);
 
1578
  }
 
1579
 }
 
1580
 return 1;
 
1581
#ifndef TOLUA_RELEASE
 
1582
 tolua_lerror:
 
1583
 tolua_error(tolua_S,"#ferror in function 'say'.",&tolua_err);
 
1584
 return 0;
 
1585
#endif
 
1586
}
 
1587
#endif //#ifndef TOLUA_DISABLE
 
1588
 
 
1589
/* method: touch of class  Ember::ServerService */
 
1590
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_touch00
 
1591
static int tolua_EmberServices_Ember_ServerService_touch00(lua_State* tolua_S)
 
1592
{
 
1593
#ifndef TOLUA_RELEASE
 
1594
 tolua_Error tolua_err;
 
1595
 if (
 
1596
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1597
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1598
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1599
 )
 
1600
  goto tolua_lerror;
 
1601
 else
 
1602
#endif
 
1603
 {
 
1604
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1605
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1606
#ifndef TOLUA_RELEASE
 
1607
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'touch'",NULL);
 
1608
#endif
 
1609
  {
 
1610
   self->touch(entity);
 
1611
  }
 
1612
 }
 
1613
 return 0;
 
1614
#ifndef TOLUA_RELEASE
 
1615
 tolua_lerror:
 
1616
 tolua_error(tolua_S,"#ferror in function 'touch'.",&tolua_err);
 
1617
 return 0;
 
1618
#endif
 
1619
}
 
1620
#endif //#ifndef TOLUA_DISABLE
 
1621
 
 
1622
/* method: emote of class  Ember::ServerService */
 
1623
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_emote00
 
1624
static int tolua_EmberServices_Ember_ServerService_emote00(lua_State* tolua_S)
 
1625
{
 
1626
#ifndef TOLUA_RELEASE
 
1627
 tolua_Error tolua_err;
 
1628
 if (
 
1629
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1630
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
1631
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1632
 )
 
1633
  goto tolua_lerror;
 
1634
 else
 
1635
#endif
 
1636
 {
 
1637
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1638
  const std::string emote = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
1639
#ifndef TOLUA_RELEASE
 
1640
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'emote'",NULL);
 
1641
#endif
 
1642
  {
 
1643
   self->emote(emote);
 
1644
   tolua_pushcppstring(tolua_S,(const char*)emote);
 
1645
  }
 
1646
 }
 
1647
 return 1;
 
1648
#ifndef TOLUA_RELEASE
 
1649
 tolua_lerror:
 
1650
 tolua_error(tolua_S,"#ferror in function 'emote'.",&tolua_err);
 
1651
 return 0;
 
1652
#endif
 
1653
}
 
1654
#endif //#ifndef TOLUA_DISABLE
 
1655
 
 
1656
/* method: drop of class  Ember::ServerService */
 
1657
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_drop00
 
1658
static int tolua_EmberServices_Ember_ServerService_drop00(lua_State* tolua_S)
 
1659
{
 
1660
#ifndef TOLUA_RELEASE
 
1661
 tolua_Error tolua_err;
 
1662
 if (
 
1663
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1664
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1665
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1666
 )
 
1667
  goto tolua_lerror;
 
1668
 else
 
1669
#endif
 
1670
 {
 
1671
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1672
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1673
#ifndef TOLUA_RELEASE
 
1674
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'drop'",NULL);
 
1675
#endif
 
1676
  {
 
1677
   self->drop(entity);
 
1678
  }
 
1679
 }
 
1680
 return 0;
 
1681
#ifndef TOLUA_RELEASE
 
1682
 tolua_lerror:
 
1683
 tolua_error(tolua_S,"#ferror in function 'drop'.",&tolua_err);
 
1684
 return 0;
 
1685
#endif
 
1686
}
 
1687
#endif //#ifndef TOLUA_DISABLE
 
1688
 
 
1689
/* method: drop of class  Ember::ServerService */
 
1690
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_drop01
 
1691
static int tolua_EmberServices_Ember_ServerService_drop01(lua_State* tolua_S)
 
1692
{
 
1693
 tolua_Error tolua_err;
 
1694
 if (
 
1695
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1696
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1697
     !tolua_isusertype(tolua_S,3,"const WFMath::Vector<3>",0,&tolua_err) ||
 
1698
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
1699
 )
 
1700
  goto tolua_lerror;
 
1701
 else
 
1702
 {
 
1703
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1704
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1705
  const WFMath::Vector<3>* offset = ((const WFMath::Vector<3>*)  tolua_tousertype(tolua_S,3,0));
 
1706
#ifndef TOLUA_RELEASE
 
1707
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'drop'",NULL);
 
1708
#endif
 
1709
  {
 
1710
   self->drop(entity,*offset);
 
1711
  }
 
1712
 }
 
1713
 return 0;
 
1714
tolua_lerror:
 
1715
 return tolua_EmberServices_Ember_ServerService_drop00(tolua_S);
 
1716
}
 
1717
#endif //#ifndef TOLUA_DISABLE
 
1718
 
 
1719
/* method: place of class  Ember::ServerService */
 
1720
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_place00
 
1721
static int tolua_EmberServices_Ember_ServerService_place00(lua_State* tolua_S)
 
1722
{
 
1723
#ifndef TOLUA_RELEASE
 
1724
 tolua_Error tolua_err;
 
1725
 if (
 
1726
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1727
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1728
     !tolua_isusertype(tolua_S,3,"Eris::Entity",0,&tolua_err) ||
 
1729
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
1730
 )
 
1731
  goto tolua_lerror;
 
1732
 else
 
1733
#endif
 
1734
 {
 
1735
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1736
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1737
  Eris::Entity* target = ((Eris::Entity*)  tolua_tousertype(tolua_S,3,0));
 
1738
#ifndef TOLUA_RELEASE
 
1739
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'place'",NULL);
 
1740
#endif
 
1741
  {
 
1742
   self->place(entity,target);
 
1743
  }
 
1744
 }
 
1745
 return 0;
 
1746
#ifndef TOLUA_RELEASE
 
1747
 tolua_lerror:
 
1748
 tolua_error(tolua_S,"#ferror in function 'place'.",&tolua_err);
 
1749
 return 0;
 
1750
#endif
 
1751
}
 
1752
#endif //#ifndef TOLUA_DISABLE
 
1753
 
 
1754
/* method: wield of class  Ember::ServerService */
 
1755
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_wield00
 
1756
static int tolua_EmberServices_Ember_ServerService_wield00(lua_State* tolua_S)
 
1757
{
 
1758
#ifndef TOLUA_RELEASE
 
1759
 tolua_Error tolua_err;
 
1760
 if (
 
1761
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1762
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1763
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1764
 )
 
1765
  goto tolua_lerror;
 
1766
 else
 
1767
#endif
 
1768
 {
 
1769
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1770
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1771
#ifndef TOLUA_RELEASE
 
1772
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'wield'",NULL);
 
1773
#endif
 
1774
  {
 
1775
   self->wield(entity);
 
1776
  }
 
1777
 }
 
1778
 return 0;
 
1779
#ifndef TOLUA_RELEASE
 
1780
 tolua_lerror:
 
1781
 tolua_error(tolua_S,"#ferror in function 'wield'.",&tolua_err);
 
1782
 return 0;
 
1783
#endif
 
1784
}
 
1785
#endif //#ifndef TOLUA_DISABLE
 
1786
 
 
1787
/* method: take of class  Ember::ServerService */
 
1788
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_take00
 
1789
static int tolua_EmberServices_Ember_ServerService_take00(lua_State* tolua_S)
 
1790
{
 
1791
#ifndef TOLUA_RELEASE
 
1792
 tolua_Error tolua_err;
 
1793
 if (
 
1794
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1795
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1796
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1797
 )
 
1798
  goto tolua_lerror;
 
1799
 else
 
1800
#endif
 
1801
 {
 
1802
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1803
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1804
#ifndef TOLUA_RELEASE
 
1805
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'take'",NULL);
 
1806
#endif
 
1807
  {
 
1808
   self->take(entity);
 
1809
  }
 
1810
 }
 
1811
 return 0;
 
1812
#ifndef TOLUA_RELEASE
 
1813
 tolua_lerror:
 
1814
 tolua_error(tolua_S,"#ferror in function 'take'.",&tolua_err);
 
1815
 return 0;
 
1816
#endif
 
1817
}
 
1818
#endif //#ifndef TOLUA_DISABLE
 
1819
 
 
1820
/* method: use of class  Ember::ServerService */
 
1821
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_use00
 
1822
static int tolua_EmberServices_Ember_ServerService_use00(lua_State* tolua_S)
 
1823
{
 
1824
#ifndef TOLUA_RELEASE
 
1825
 tolua_Error tolua_err;
 
1826
 if (
 
1827
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1828
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1829
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1830
 )
 
1831
  goto tolua_lerror;
 
1832
 else
 
1833
#endif
 
1834
 {
 
1835
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1836
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1837
#ifndef TOLUA_RELEASE
 
1838
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'use'",NULL);
 
1839
#endif
 
1840
  {
 
1841
   self->use(entity);
 
1842
  }
 
1843
 }
 
1844
 return 0;
 
1845
#ifndef TOLUA_RELEASE
 
1846
 tolua_lerror:
 
1847
 tolua_error(tolua_S,"#ferror in function 'use'.",&tolua_err);
 
1848
 return 0;
 
1849
#endif
 
1850
}
 
1851
#endif //#ifndef TOLUA_DISABLE
 
1852
 
 
1853
/* method: use of class  Ember::ServerService */
 
1854
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_use01
 
1855
static int tolua_EmberServices_Ember_ServerService_use01(lua_State* tolua_S)
 
1856
{
 
1857
 tolua_Error tolua_err;
 
1858
 if (
 
1859
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1860
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1861
     !tolua_isusertype(tolua_S,3,"WFMath::Point<3>",0,&tolua_err) ||
 
1862
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
1863
 )
 
1864
  goto tolua_lerror;
 
1865
 else
 
1866
 {
 
1867
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1868
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1869
  WFMath::Point<3> pos = *((WFMath::Point<3>*)  tolua_tousertype(tolua_S,3,0));
 
1870
#ifndef TOLUA_RELEASE
 
1871
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'use'",NULL);
 
1872
#endif
 
1873
  {
 
1874
   self->use(entity,pos);
 
1875
  }
 
1876
 }
 
1877
 return 0;
 
1878
tolua_lerror:
 
1879
 return tolua_EmberServices_Ember_ServerService_use00(tolua_S);
 
1880
}
 
1881
#endif //#ifndef TOLUA_DISABLE
 
1882
 
 
1883
/* method: use of class  Ember::ServerService */
 
1884
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_use02
 
1885
static int tolua_EmberServices_Ember_ServerService_use02(lua_State* tolua_S)
 
1886
{
 
1887
 tolua_Error tolua_err;
 
1888
 if (
 
1889
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1890
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1891
     !tolua_isusertype(tolua_S,3,"WFMath::Point<3>",0,&tolua_err) ||
 
1892
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
 
1893
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 
1894
 )
 
1895
  goto tolua_lerror;
 
1896
 else
 
1897
 {
 
1898
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1899
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1900
  WFMath::Point<3> pos = *((WFMath::Point<3>*)  tolua_tousertype(tolua_S,3,0));
 
1901
  const std::string operation = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
 
1902
#ifndef TOLUA_RELEASE
 
1903
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'use'",NULL);
 
1904
#endif
 
1905
  {
 
1906
   self->use(entity,pos,operation);
 
1907
   tolua_pushcppstring(tolua_S,(const char*)operation);
 
1908
  }
 
1909
 }
 
1910
 return 1;
 
1911
tolua_lerror:
 
1912
 return tolua_EmberServices_Ember_ServerService_use01(tolua_S);
 
1913
}
 
1914
#endif //#ifndef TOLUA_DISABLE
 
1915
 
 
1916
/* method: useStop of class  Ember::ServerService */
 
1917
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_useStop00
 
1918
static int tolua_EmberServices_Ember_ServerService_useStop00(lua_State* tolua_S)
 
1919
{
 
1920
#ifndef TOLUA_RELEASE
 
1921
 tolua_Error tolua_err;
 
1922
 if (
 
1923
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1924
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
1925
 )
 
1926
  goto tolua_lerror;
 
1927
 else
 
1928
#endif
 
1929
 {
 
1930
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1931
#ifndef TOLUA_RELEASE
 
1932
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'useStop'",NULL);
 
1933
#endif
 
1934
  {
 
1935
   self->useStop();
 
1936
  }
 
1937
 }
 
1938
 return 0;
 
1939
#ifndef TOLUA_RELEASE
 
1940
 tolua_lerror:
 
1941
 tolua_error(tolua_S,"#ferror in function 'useStop'.",&tolua_err);
 
1942
 return 0;
 
1943
#endif
 
1944
}
 
1945
#endif //#ifndef TOLUA_DISABLE
 
1946
 
 
1947
/* method: actuate of class  Ember::ServerService */
 
1948
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_actuate00
 
1949
static int tolua_EmberServices_Ember_ServerService_actuate00(lua_State* tolua_S)
 
1950
{
 
1951
#ifndef TOLUA_RELEASE
 
1952
 tolua_Error tolua_err;
 
1953
 if (
 
1954
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1955
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1956
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
 
1957
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
1958
 )
 
1959
  goto tolua_lerror;
 
1960
 else
 
1961
#endif
 
1962
 {
 
1963
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1964
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
1965
  const std::string action = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
 
1966
#ifndef TOLUA_RELEASE
 
1967
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'actuate'",NULL);
 
1968
#endif
 
1969
  {
 
1970
   self->actuate(entity,action);
 
1971
   tolua_pushcppstring(tolua_S,(const char*)action);
 
1972
  }
 
1973
 }
 
1974
 return 1;
 
1975
#ifndef TOLUA_RELEASE
 
1976
 tolua_lerror:
 
1977
 tolua_error(tolua_S,"#ferror in function 'actuate'.",&tolua_err);
 
1978
 return 0;
 
1979
#endif
 
1980
}
 
1981
#endif //#ifndef TOLUA_DISABLE
 
1982
 
 
1983
/* method: attack of class  Ember::ServerService */
 
1984
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_attack00
 
1985
static int tolua_EmberServices_Ember_ServerService_attack00(lua_State* tolua_S)
 
1986
{
 
1987
#ifndef TOLUA_RELEASE
 
1988
 tolua_Error tolua_err;
 
1989
 if (
 
1990
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
1991
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
1992
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
1993
 )
 
1994
  goto tolua_lerror;
 
1995
 else
 
1996
#endif
 
1997
 {
 
1998
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
1999
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
2000
#ifndef TOLUA_RELEASE
 
2001
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'attack'",NULL);
 
2002
#endif
 
2003
  {
 
2004
   self->attack(entity);
 
2005
  }
 
2006
 }
 
2007
 return 0;
 
2008
#ifndef TOLUA_RELEASE
 
2009
 tolua_lerror:
 
2010
 tolua_error(tolua_S,"#ferror in function 'attack'.",&tolua_err);
 
2011
 return 0;
 
2012
#endif
 
2013
}
 
2014
#endif //#ifndef TOLUA_DISABLE
 
2015
 
 
2016
/* method: eat of class  Ember::ServerService */
 
2017
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_eat00
 
2018
static int tolua_EmberServices_Ember_ServerService_eat00(lua_State* tolua_S)
 
2019
{
 
2020
#ifndef TOLUA_RELEASE
 
2021
 tolua_Error tolua_err;
 
2022
 if (
 
2023
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
2024
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
2025
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2026
 )
 
2027
  goto tolua_lerror;
 
2028
 else
 
2029
#endif
 
2030
 {
 
2031
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2032
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
2033
#ifndef TOLUA_RELEASE
 
2034
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'eat'",NULL);
 
2035
#endif
 
2036
  {
 
2037
   self->eat(entity);
 
2038
  }
 
2039
 }
 
2040
 return 0;
 
2041
#ifndef TOLUA_RELEASE
 
2042
 tolua_lerror:
 
2043
 tolua_error(tolua_S,"#ferror in function 'eat'.",&tolua_err);
 
2044
 return 0;
 
2045
#endif
 
2046
}
 
2047
#endif //#ifndef TOLUA_DISABLE
 
2048
 
 
2049
/* method: deleteEntity of class  Ember::ServerService */
 
2050
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_deleteEntity00
 
2051
static int tolua_EmberServices_Ember_ServerService_deleteEntity00(lua_State* tolua_S)
 
2052
{
 
2053
#ifndef TOLUA_RELEASE
 
2054
 tolua_Error tolua_err;
 
2055
 if (
 
2056
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
2057
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
2058
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2059
 )
 
2060
  goto tolua_lerror;
 
2061
 else
 
2062
#endif
 
2063
 {
 
2064
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2065
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
2066
#ifndef TOLUA_RELEASE
 
2067
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'deleteEntity'",NULL);
 
2068
#endif
 
2069
  {
 
2070
   self->deleteEntity(entity);
 
2071
  }
 
2072
 }
 
2073
 return 0;
 
2074
#ifndef TOLUA_RELEASE
 
2075
 tolua_lerror:
 
2076
 tolua_error(tolua_S,"#ferror in function 'deleteEntity'.",&tolua_err);
 
2077
 return 0;
 
2078
#endif
 
2079
}
 
2080
#endif //#ifndef TOLUA_DISABLE
 
2081
 
 
2082
/* method: setAttributes of class  Ember::ServerService */
 
2083
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_setAttributes00
 
2084
static int tolua_EmberServices_Ember_ServerService_setAttributes00(lua_State* tolua_S)
 
2085
{
 
2086
#ifndef TOLUA_RELEASE
 
2087
 tolua_Error tolua_err;
 
2088
 if (
 
2089
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
 
2090
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
 
2091
     !tolua_isusertype(tolua_S,3,"Atlas::Message::MapType",0,&tolua_err) ||
 
2092
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
2093
 )
 
2094
  goto tolua_lerror;
 
2095
 else
 
2096
#endif
 
2097
 {
 
2098
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2099
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
 
2100
  Atlas::Message::MapType* attributes = ((Atlas::Message::MapType*)  tolua_tousertype(tolua_S,3,0));
 
2101
#ifndef TOLUA_RELEASE
 
2102
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAttributes'",NULL);
 
2103
#endif
 
2104
  {
 
2105
   self->setAttributes(entity,*attributes);
 
2106
  }
 
2107
 }
 
2108
 return 0;
 
2109
#ifndef TOLUA_RELEASE
 
2110
 tolua_lerror:
 
2111
 tolua_error(tolua_S,"#ferror in function 'setAttributes'.",&tolua_err);
 
2112
 return 0;
 
2113
#endif
 
2114
}
 
2115
#endif //#ifndef TOLUA_DISABLE
 
2116
 
 
2117
/* get function: GotAvatar of class  Ember::ServerService */
 
2118
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotAvatar
 
2119
static int tolua_get_Ember__ServerService_GotAvatar(lua_State* tolua_S)
 
2120
{
 
2121
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2122
#ifndef TOLUA_RELEASE
 
2123
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAvatar'",NULL);
 
2124
#endif
 
2125
  tolua_pushusertype(tolua_S,(void*)&self->GotAvatar,"sigc::signal<void,Eris::Avatar*>");
 
2126
 return 1;
 
2127
}
 
2128
#endif //#ifndef TOLUA_DISABLE
 
2129
 
 
2130
/* set function: GotAvatar of class  Ember::ServerService */
 
2131
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotAvatar
 
2132
static int tolua_set_Ember__ServerService_GotAvatar(lua_State* tolua_S)
 
2133
{
 
2134
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2135
#ifndef TOLUA_RELEASE
 
2136
  tolua_Error tolua_err;
 
2137
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAvatar'",NULL);
 
2138
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Avatar*>",0,&tolua_err))
 
2139
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
2140
#endif
 
2141
  self->GotAvatar = *((sigc::signal<void,Eris::Avatar*>*)  tolua_tousertype(tolua_S,2,0))
 
2142
;
 
2143
 return 0;
 
2144
}
 
2145
#endif //#ifndef TOLUA_DISABLE
 
2146
 
 
2147
/* get function: GotView of class  Ember::ServerService */
 
2148
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotView
 
2149
static int tolua_get_Ember__ServerService_GotView(lua_State* tolua_S)
 
2150
{
 
2151
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2152
#ifndef TOLUA_RELEASE
 
2153
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotView'",NULL);
 
2154
#endif
 
2155
  tolua_pushusertype(tolua_S,(void*)&self->GotView,"sigc::signal<void,Eris::View*>");
 
2156
 return 1;
 
2157
}
 
2158
#endif //#ifndef TOLUA_DISABLE
 
2159
 
 
2160
/* set function: GotView of class  Ember::ServerService */
 
2161
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotView
 
2162
static int tolua_set_Ember__ServerService_GotView(lua_State* tolua_S)
 
2163
{
 
2164
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2165
#ifndef TOLUA_RELEASE
 
2166
  tolua_Error tolua_err;
 
2167
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotView'",NULL);
 
2168
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::View*>",0,&tolua_err))
 
2169
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
2170
#endif
 
2171
  self->GotView = *((sigc::signal<void,Eris::View*>*)  tolua_tousertype(tolua_S,2,0))
 
2172
;
 
2173
 return 0;
 
2174
}
 
2175
#endif //#ifndef TOLUA_DISABLE
 
2176
 
 
2177
/* get function: GotConnection of class  Ember::ServerService */
 
2178
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotConnection
 
2179
static int tolua_get_Ember__ServerService_GotConnection(lua_State* tolua_S)
 
2180
{
 
2181
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2182
#ifndef TOLUA_RELEASE
 
2183
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotConnection'",NULL);
 
2184
#endif
 
2185
  tolua_pushusertype(tolua_S,(void*)&self->GotConnection,"sigc::signal<void,Eris::Connection*>");
 
2186
 return 1;
 
2187
}
 
2188
#endif //#ifndef TOLUA_DISABLE
 
2189
 
 
2190
/* set function: GotConnection of class  Ember::ServerService */
 
2191
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotConnection
 
2192
static int tolua_set_Ember__ServerService_GotConnection(lua_State* tolua_S)
 
2193
{
 
2194
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2195
#ifndef TOLUA_RELEASE
 
2196
  tolua_Error tolua_err;
 
2197
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotConnection'",NULL);
 
2198
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Connection*>",0,&tolua_err))
 
2199
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
2200
#endif
 
2201
  self->GotConnection = *((sigc::signal<void,Eris::Connection*>*)  tolua_tousertype(tolua_S,2,0))
 
2202
;
 
2203
 return 0;
 
2204
}
 
2205
#endif //#ifndef TOLUA_DISABLE
 
2206
 
 
2207
/* get function: GotAccount of class  Ember::ServerService */
 
2208
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotAccount
 
2209
static int tolua_get_Ember__ServerService_GotAccount(lua_State* tolua_S)
 
2210
{
 
2211
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2212
#ifndef TOLUA_RELEASE
 
2213
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAccount'",NULL);
 
2214
#endif
 
2215
  tolua_pushusertype(tolua_S,(void*)&self->GotAccount,"sigc::signal<void,Eris::Account*>");
 
2216
 return 1;
 
2217
}
 
2218
#endif //#ifndef TOLUA_DISABLE
 
2219
 
 
2220
/* set function: GotAccount of class  Ember::ServerService */
 
2221
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotAccount
 
2222
static int tolua_set_Ember__ServerService_GotAccount(lua_State* tolua_S)
 
2223
{
 
2224
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2225
#ifndef TOLUA_RELEASE
 
2226
  tolua_Error tolua_err;
 
2227
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAccount'",NULL);
 
2228
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Account*>",0,&tolua_err))
 
2229
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
2230
#endif
 
2231
  self->GotAccount = *((sigc::signal<void,Eris::Account*>*)  tolua_tousertype(tolua_S,2,0))
 
2232
;
 
2233
 return 0;
 
2234
}
 
2235
#endif //#ifndef TOLUA_DISABLE
 
2236
 
 
2237
/* get function: LoginSuccess of class  Ember::ServerService */
 
2238
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_LoginSuccess
 
2239
static int tolua_get_Ember__ServerService_LoginSuccess(lua_State* tolua_S)
 
2240
{
 
2241
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2242
#ifndef TOLUA_RELEASE
 
2243
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'LoginSuccess'",NULL);
 
2244
#endif
 
2245
  tolua_pushusertype(tolua_S,(void*)&self->LoginSuccess,"sigc::signal<void,Eris::Account*>");
 
2246
 return 1;
 
2247
}
 
2248
#endif //#ifndef TOLUA_DISABLE
 
2249
 
 
2250
/* set function: LoginSuccess of class  Ember::ServerService */
 
2251
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_LoginSuccess
 
2252
static int tolua_set_Ember__ServerService_LoginSuccess(lua_State* tolua_S)
 
2253
{
 
2254
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2255
#ifndef TOLUA_RELEASE
 
2256
  tolua_Error tolua_err;
 
2257
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'LoginSuccess'",NULL);
 
2258
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Account*>",0,&tolua_err))
 
2259
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
2260
#endif
 
2261
  self->LoginSuccess = *((sigc::signal<void,Eris::Account*>*)  tolua_tousertype(tolua_S,2,0))
 
2262
;
 
2263
 return 0;
 
2264
}
 
2265
#endif //#ifndef TOLUA_DISABLE
 
2266
 
 
2267
/* get function: LoginFailure of class  Ember::ServerService */
 
2268
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_LoginFailure
 
2269
static int tolua_get_Ember__ServerService_LoginFailure(lua_State* tolua_S)
 
2270
{
 
2271
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2272
#ifndef TOLUA_RELEASE
 
2273
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'LoginFailure'",NULL);
 
2274
#endif
 
2275
  tolua_pushusertype(tolua_S,(void*)&self->LoginFailure,"sigc::signal<void,Eris::Account*,const std::string&>");
 
2276
 return 1;
 
2277
}
 
2278
#endif //#ifndef TOLUA_DISABLE
 
2279
 
 
2280
/* set function: LoginFailure of class  Ember::ServerService */
 
2281
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_LoginFailure
 
2282
static int tolua_set_Ember__ServerService_LoginFailure(lua_State* tolua_S)
 
2283
{
 
2284
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2285
#ifndef TOLUA_RELEASE
 
2286
  tolua_Error tolua_err;
 
2287
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'LoginFailure'",NULL);
 
2288
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Account*,const std::string&>",0,&tolua_err))
 
2289
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
2290
#endif
 
2291
  self->LoginFailure = *((sigc::signal<void,Eris::Account*,const std::string&>*)  tolua_tousertype(tolua_S,2,0))
 
2292
;
 
2293
 return 0;
 
2294
}
 
2295
#endif //#ifndef TOLUA_DISABLE
 
2296
 
 
2297
/* get function: GotCharacterInfo of class  Ember::ServerService */
 
2298
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotCharacterInfo
 
2299
static int tolua_get_Ember__ServerService_GotCharacterInfo(lua_State* tolua_S)
 
2300
{
 
2301
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2302
#ifndef TOLUA_RELEASE
 
2303
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotCharacterInfo'",NULL);
 
2304
#endif
 
2305
  tolua_pushusertype(tolua_S,(void*)&self->GotCharacterInfo,"sigc::signal<void,const Atlas::Objects::Entity::RootEntity&>");
 
2306
 return 1;
 
2307
}
 
2308
#endif //#ifndef TOLUA_DISABLE
 
2309
 
 
2310
/* set function: GotCharacterInfo of class  Ember::ServerService */
 
2311
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotCharacterInfo
 
2312
static int tolua_set_Ember__ServerService_GotCharacterInfo(lua_State* tolua_S)
 
2313
{
 
2314
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2315
#ifndef TOLUA_RELEASE
 
2316
  tolua_Error tolua_err;
 
2317
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotCharacterInfo'",NULL);
 
2318
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,const Atlas::Objects::Entity::RootEntity&>",0,&tolua_err))
 
2319
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
2320
#endif
 
2321
  self->GotCharacterInfo = *((sigc::signal<void,const Atlas::Objects::Entity::RootEntity&>*)  tolua_tousertype(tolua_S,2,0))
 
2322
;
 
2323
 return 0;
 
2324
}
 
2325
#endif //#ifndef TOLUA_DISABLE
 
2326
 
 
2327
/* get function: GotAllCharacters of class  Ember::ServerService */
 
2328
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotAllCharacters
 
2329
static int tolua_get_Ember__ServerService_GotAllCharacters(lua_State* tolua_S)
 
2330
{
 
2331
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2332
#ifndef TOLUA_RELEASE
 
2333
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAllCharacters'",NULL);
 
2334
#endif
 
2335
  tolua_pushusertype(tolua_S,(void*)&self->GotAllCharacters,"sigc::signal<void,Eris::Account*>");
 
2336
 return 1;
 
2337
}
 
2338
#endif //#ifndef TOLUA_DISABLE
 
2339
 
 
2340
/* set function: GotAllCharacters of class  Ember::ServerService */
 
2341
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotAllCharacters
 
2342
static int tolua_set_Ember__ServerService_GotAllCharacters(lua_State* tolua_S)
 
2343
{
 
2344
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
 
2345
#ifndef TOLUA_RELEASE
 
2346
  tolua_Error tolua_err;
 
2347
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAllCharacters'",NULL);
 
2348
  if (!tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Account*>",0,&tolua_err))
 
2349
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 
2350
#endif
 
2351
  self->GotAllCharacters = *((sigc::signal<void,Eris::Account*>*)  tolua_tousertype(tolua_S,2,0))
 
2352
;
 
2353
 return 0;
 
2354
}
 
2355
#endif //#ifndef TOLUA_DISABLE
 
2356
 
 
2357
/* method: registerScriptingProvider of class  Ember::ScriptingService */
 
2358
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_registerScriptingProvider00
 
2359
static int tolua_EmberServices_Ember_ScriptingService_registerScriptingProvider00(lua_State* tolua_S)
 
2360
{
 
2361
#ifndef TOLUA_RELEASE
 
2362
 tolua_Error tolua_err;
 
2363
 if (
 
2364
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
 
2365
     !tolua_isusertype(tolua_S,2,"Ember::IScriptingProvider",0,&tolua_err) ||
 
2366
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2367
 )
 
2368
  goto tolua_lerror;
 
2369
 else
 
2370
#endif
 
2371
 {
 
2372
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
 
2373
  Ember::IScriptingProvider* provider = ((Ember::IScriptingProvider*)  tolua_tousertype(tolua_S,2,0));
 
2374
#ifndef TOLUA_RELEASE
 
2375
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'registerScriptingProvider'",NULL);
 
2376
#endif
 
2377
  {
 
2378
   self->registerScriptingProvider(provider);
 
2379
  }
 
2380
 }
 
2381
 return 0;
 
2382
#ifndef TOLUA_RELEASE
 
2383
 tolua_lerror:
 
2384
 tolua_error(tolua_S,"#ferror in function 'registerScriptingProvider'.",&tolua_err);
 
2385
 return 0;
 
2386
#endif
 
2387
}
 
2388
#endif //#ifndef TOLUA_DISABLE
 
2389
 
 
2390
/* method: loadScript of class  Ember::ScriptingService */
 
2391
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_loadScript00
 
2392
static int tolua_EmberServices_Ember_ScriptingService_loadScript00(lua_State* tolua_S)
 
2393
{
 
2394
#ifndef TOLUA_RELEASE
 
2395
 tolua_Error tolua_err;
 
2396
 if (
 
2397
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
 
2398
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
2399
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2400
 )
 
2401
  goto tolua_lerror;
 
2402
 else
 
2403
#endif
 
2404
 {
 
2405
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
 
2406
  const std::string script = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
2407
#ifndef TOLUA_RELEASE
 
2408
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadScript'",NULL);
 
2409
#endif
 
2410
  {
 
2411
   self->loadScript(script);
 
2412
   tolua_pushcppstring(tolua_S,(const char*)script);
 
2413
  }
 
2414
 }
 
2415
 return 1;
 
2416
#ifndef TOLUA_RELEASE
 
2417
 tolua_lerror:
 
2418
 tolua_error(tolua_S,"#ferror in function 'loadScript'.",&tolua_err);
 
2419
 return 0;
 
2420
#endif
 
2421
}
 
2422
#endif //#ifndef TOLUA_DISABLE
 
2423
 
 
2424
/* method: executeCode of class  Ember::ScriptingService */
 
2425
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_executeCode00
 
2426
static int tolua_EmberServices_Ember_ScriptingService_executeCode00(lua_State* tolua_S)
 
2427
{
 
2428
#ifndef TOLUA_RELEASE
 
2429
 tolua_Error tolua_err;
 
2430
 if (
 
2431
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
 
2432
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
2433
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
 
2434
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
2435
 )
 
2436
  goto tolua_lerror;
 
2437
 else
 
2438
#endif
 
2439
 {
 
2440
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
 
2441
  const std::string scriptCode = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
2442
  const std::string scriptType = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
 
2443
#ifndef TOLUA_RELEASE
 
2444
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'executeCode'",NULL);
 
2445
#endif
 
2446
  {
 
2447
   self->executeCode(scriptCode,scriptType);
 
2448
   tolua_pushcppstring(tolua_S,(const char*)scriptCode);
 
2449
   tolua_pushcppstring(tolua_S,(const char*)scriptType);
 
2450
  }
 
2451
 }
 
2452
 return 2;
 
2453
#ifndef TOLUA_RELEASE
 
2454
 tolua_lerror:
 
2455
 tolua_error(tolua_S,"#ferror in function 'executeCode'.",&tolua_err);
 
2456
 return 0;
 
2457
#endif
 
2458
}
 
2459
#endif //#ifndef TOLUA_DISABLE
 
2460
 
 
2461
/* method: getEventScriptError of class  Ember::ScriptingService */
 
2462
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_getEventScriptError00
 
2463
static int tolua_EmberServices_Ember_ScriptingService_getEventScriptError00(lua_State* tolua_S)
 
2464
{
 
2465
#ifndef TOLUA_RELEASE
 
2466
 tolua_Error tolua_err;
 
2467
 if (
 
2468
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
 
2469
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2470
 )
 
2471
  goto tolua_lerror;
 
2472
 else
 
2473
#endif
 
2474
 {
 
2475
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
 
2476
#ifndef TOLUA_RELEASE
 
2477
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEventScriptError'",NULL);
 
2478
#endif
 
2479
  {
 
2480
   sigc::signal<void,const std::string&>& tolua_ret = (sigc::signal<void,const std::string&>&)  self->getEventScriptError();
 
2481
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"sigc::signal<void,const std::string&>");
 
2482
  }
 
2483
 }
 
2484
 return 1;
 
2485
#ifndef TOLUA_RELEASE
 
2486
 tolua_lerror:
 
2487
 tolua_error(tolua_S,"#ferror in function 'getEventScriptError'.",&tolua_err);
 
2488
 return 0;
 
2489
#endif
 
2490
}
 
2491
#endif //#ifndef TOLUA_DISABLE
 
2492
 
 
2493
/* method: getProviderFor of class  Ember::ScriptingService */
 
2494
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_getProviderFor00
 
2495
static int tolua_EmberServices_Ember_ScriptingService_getProviderFor00(lua_State* tolua_S)
 
2496
{
 
2497
#ifndef TOLUA_RELEASE
 
2498
 tolua_Error tolua_err;
 
2499
 if (
 
2500
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
 
2501
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
 
2502
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2503
 )
 
2504
  goto tolua_lerror;
 
2505
 else
 
2506
#endif
 
2507
 {
 
2508
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
 
2509
  const std::string providerName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
 
2510
#ifndef TOLUA_RELEASE
 
2511
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getProviderFor'",NULL);
 
2512
#endif
 
2513
  {
 
2514
   Ember::IScriptingProvider* tolua_ret = (Ember::IScriptingProvider*)  self->getProviderFor(providerName);
 
2515
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::IScriptingProvider");
 
2516
   tolua_pushcppstring(tolua_S,(const char*)providerName);
 
2517
  }
 
2518
 }
 
2519
 return 2;
 
2520
#ifndef TOLUA_RELEASE
 
2521
 tolua_lerror:
 
2522
 tolua_error(tolua_S,"#ferror in function 'getProviderFor'.",&tolua_err);
 
2523
 return 0;
 
2524
#endif
 
2525
}
 
2526
#endif //#ifndef TOLUA_DISABLE
 
2527
 
 
2528
/* method: getProviderNames of class  Ember::ScriptingService */
 
2529
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_getProviderNames00
 
2530
static int tolua_EmberServices_Ember_ScriptingService_getProviderNames00(lua_State* tolua_S)
 
2531
{
 
2532
#ifndef TOLUA_RELEASE
 
2533
 tolua_Error tolua_err;
 
2534
 if (
 
2535
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
 
2536
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2537
 )
 
2538
  goto tolua_lerror;
 
2539
 else
 
2540
#endif
 
2541
 {
 
2542
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
 
2543
#ifndef TOLUA_RELEASE
 
2544
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getProviderNames'",NULL);
 
2545
#endif
 
2546
  {
 
2547
   std::vector<std::string> tolua_ret = (std::vector<std::string>)  self->getProviderNames();
 
2548
   {
 
2549
#ifdef __cplusplus
 
2550
    void* tolua_obj = new std::vector<std::string>(tolua_ret);
 
2551
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"std::vector<std::string>");
 
2552
#else
 
2553
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<std::string>));
 
2554
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"std::vector<std::string>");
 
2555
#endif
 
2556
   }
 
2557
  }
 
2558
 }
 
2559
 return 1;
 
2560
#ifndef TOLUA_RELEASE
 
2561
 tolua_lerror:
 
2562
 tolua_error(tolua_S,"#ferror in function 'getProviderNames'.",&tolua_err);
 
2563
 return 0;
 
2564
#endif
 
2565
}
 
2566
#endif //#ifndef TOLUA_DISABLE
 
2567
 
 
2568
/* method: getAlwaysLookup of class  Ember::ScriptingService */
 
2569
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_getAlwaysLookup00
 
2570
static int tolua_EmberServices_Ember_ScriptingService_getAlwaysLookup00(lua_State* tolua_S)
 
2571
{
 
2572
#ifndef TOLUA_RELEASE
 
2573
 tolua_Error tolua_err;
 
2574
 if (
 
2575
     !tolua_isusertype(tolua_S,1,"const Ember::ScriptingService",0,&tolua_err) ||
 
2576
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2577
 )
 
2578
  goto tolua_lerror;
 
2579
 else
 
2580
#endif
 
2581
 {
 
2582
  const Ember::ScriptingService* self = (const Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
 
2583
#ifndef TOLUA_RELEASE
 
2584
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAlwaysLookup'",NULL);
 
2585
#endif
 
2586
  {
 
2587
   bool tolua_ret = (bool)  self->getAlwaysLookup();
 
2588
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
2589
  }
 
2590
 }
 
2591
 return 1;
 
2592
#ifndef TOLUA_RELEASE
 
2593
 tolua_lerror:
 
2594
 tolua_error(tolua_S,"#ferror in function 'getAlwaysLookup'.",&tolua_err);
 
2595
 return 0;
 
2596
#endif
 
2597
}
 
2598
#endif //#ifndef TOLUA_DISABLE
 
2599
 
 
2600
/* method: setAlwaysLookup of class  Ember::ScriptingService */
 
2601
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_setAlwaysLookup00
 
2602
static int tolua_EmberServices_Ember_ScriptingService_setAlwaysLookup00(lua_State* tolua_S)
 
2603
{
 
2604
#ifndef TOLUA_RELEASE
 
2605
 tolua_Error tolua_err;
 
2606
 if (
 
2607
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
 
2608
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 
2609
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2610
 )
 
2611
  goto tolua_lerror;
 
2612
 else
 
2613
#endif
 
2614
 {
 
2615
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
 
2616
  bool alwaysLookup = ((bool)  tolua_toboolean(tolua_S,2,0));
 
2617
#ifndef TOLUA_RELEASE
 
2618
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlwaysLookup'",NULL);
 
2619
#endif
 
2620
  {
 
2621
   self->setAlwaysLookup(alwaysLookup);
 
2622
  }
 
2623
 }
 
2624
 return 0;
 
2625
#ifndef TOLUA_RELEASE
 
2626
 tolua_lerror:
 
2627
 tolua_error(tolua_S,"#ferror in function 'setAlwaysLookup'.",&tolua_err);
 
2628
 return 0;
 
2629
#endif
 
2630
}
 
2631
#endif //#ifndef TOLUA_DISABLE
 
2632
 
 
2633
/* method: getInput of class  Ember::InputService */
 
2634
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_InputService_getInput00
 
2635
static int tolua_EmberServices_Ember_InputService_getInput00(lua_State* tolua_S)
 
2636
{
 
2637
#ifndef TOLUA_RELEASE
 
2638
 tolua_Error tolua_err;
 
2639
 if (
 
2640
     !tolua_isusertype(tolua_S,1,"Ember::InputService",0,&tolua_err) ||
 
2641
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2642
 )
 
2643
  goto tolua_lerror;
 
2644
 else
 
2645
#endif
 
2646
 {
 
2647
  Ember::InputService* self = (Ember::InputService*)  tolua_tousertype(tolua_S,1,0);
 
2648
#ifndef TOLUA_RELEASE
 
2649
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInput'",NULL);
 
2650
#endif
 
2651
  {
 
2652
   Ember::Input& tolua_ret = (Ember::Input&)  self->getInput();
 
2653
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::Input");
 
2654
  }
 
2655
 }
 
2656
 return 1;
 
2657
#ifndef TOLUA_RELEASE
 
2658
 tolua_lerror:
 
2659
 tolua_error(tolua_S,"#ferror in function 'getInput'.",&tolua_err);
 
2660
 return 0;
 
2661
#endif
 
2662
}
 
2663
#endif //#ifndef TOLUA_DISABLE
 
2664
 
 
2665
/* method: delete of class  Ember::IInputAdapter */
 
2666
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_delete00
 
2667
static int tolua_EmberServices_Ember_IInputAdapter_delete00(lua_State* tolua_S)
 
2668
{
 
2669
#ifndef TOLUA_RELEASE
 
2670
 tolua_Error tolua_err;
 
2671
 if (
 
2672
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
 
2673
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2674
 )
 
2675
  goto tolua_lerror;
 
2676
 else
 
2677
#endif
 
2678
 {
 
2679
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
 
2680
#ifndef TOLUA_RELEASE
 
2681
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
 
2682
#endif
 
2683
  delete self;
 
2684
 }
 
2685
 return 0;
 
2686
#ifndef TOLUA_RELEASE
 
2687
 tolua_lerror:
 
2688
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 
2689
 return 0;
 
2690
#endif
 
2691
}
 
2692
#endif //#ifndef TOLUA_DISABLE
 
2693
 
 
2694
/* method: injectMouseMove of class  Ember::IInputAdapter */
 
2695
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectMouseMove00
 
2696
static int tolua_EmberServices_Ember_IInputAdapter_injectMouseMove00(lua_State* tolua_S)
 
2697
{
 
2698
#ifndef TOLUA_RELEASE
 
2699
 tolua_Error tolua_err;
 
2700
 if (
 
2701
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
 
2702
     !tolua_isusertype(tolua_S,2,"const Ember::MouseMotion",0,&tolua_err) ||
 
2703
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
 
2704
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 
2705
 )
 
2706
  goto tolua_lerror;
 
2707
 else
 
2708
#endif
 
2709
 {
 
2710
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
 
2711
  const Ember::MouseMotion* motion = ((const Ember::MouseMotion*)  tolua_tousertype(tolua_S,2,0));
 
2712
  bool freezeMouse = ((bool)  tolua_toboolean(tolua_S,3,0));
 
2713
#ifndef TOLUA_RELEASE
 
2714
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseMove'",NULL);
 
2715
#endif
 
2716
  {
 
2717
   bool tolua_ret = (bool)  self->injectMouseMove(*motion,freezeMouse);
 
2718
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
2719
   tolua_pushboolean(tolua_S,(bool)freezeMouse);
 
2720
  }
 
2721
 }
 
2722
 return 2;
 
2723
#ifndef TOLUA_RELEASE
 
2724
 tolua_lerror:
 
2725
 tolua_error(tolua_S,"#ferror in function 'injectMouseMove'.",&tolua_err);
 
2726
 return 0;
 
2727
#endif
 
2728
}
 
2729
#endif //#ifndef TOLUA_DISABLE
 
2730
 
 
2731
/* method: injectMouseButtonUp of class  Ember::IInputAdapter */
 
2732
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonUp00
 
2733
static int tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonUp00(lua_State* tolua_S)
 
2734
{
 
2735
#ifndef TOLUA_RELEASE
 
2736
 tolua_Error tolua_err;
 
2737
 if (
 
2738
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
 
2739
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 
2740
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2741
 )
 
2742
  goto tolua_lerror;
 
2743
 else
 
2744
#endif
 
2745
 {
 
2746
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
 
2747
  const Ember::Input::MouseButton button = ((const Ember::Input::MouseButton)  tolua_tonumber(tolua_S,2,0));
 
2748
#ifndef TOLUA_RELEASE
 
2749
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseButtonUp'",NULL);
 
2750
#endif
 
2751
  {
 
2752
   bool tolua_ret = (bool)  self->injectMouseButtonUp(button);
 
2753
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
2754
   tolua_pushnumber(tolua_S,(lua_Number)button);
 
2755
  }
 
2756
 }
 
2757
 return 2;
 
2758
#ifndef TOLUA_RELEASE
 
2759
 tolua_lerror:
 
2760
 tolua_error(tolua_S,"#ferror in function 'injectMouseButtonUp'.",&tolua_err);
 
2761
 return 0;
 
2762
#endif
 
2763
}
 
2764
#endif //#ifndef TOLUA_DISABLE
 
2765
 
 
2766
/* method: injectMouseButtonDown of class  Ember::IInputAdapter */
 
2767
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonDown00
 
2768
static int tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonDown00(lua_State* tolua_S)
 
2769
{
 
2770
#ifndef TOLUA_RELEASE
 
2771
 tolua_Error tolua_err;
 
2772
 if (
 
2773
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
 
2774
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 
2775
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2776
 )
 
2777
  goto tolua_lerror;
 
2778
 else
 
2779
#endif
 
2780
 {
 
2781
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
 
2782
  const Ember::Input::MouseButton button = ((const Ember::Input::MouseButton)  tolua_tonumber(tolua_S,2,0));
 
2783
#ifndef TOLUA_RELEASE
 
2784
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseButtonDown'",NULL);
 
2785
#endif
 
2786
  {
 
2787
   bool tolua_ret = (bool)  self->injectMouseButtonDown(button);
 
2788
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
2789
   tolua_pushnumber(tolua_S,(lua_Number)button);
 
2790
  }
 
2791
 }
 
2792
 return 2;
 
2793
#ifndef TOLUA_RELEASE
 
2794
 tolua_lerror:
 
2795
 tolua_error(tolua_S,"#ferror in function 'injectMouseButtonDown'.",&tolua_err);
 
2796
 return 0;
 
2797
#endif
 
2798
}
 
2799
#endif //#ifndef TOLUA_DISABLE
 
2800
 
 
2801
/* method: injectChar of class  Ember::IInputAdapter */
 
2802
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectChar00
 
2803
static int tolua_EmberServices_Ember_IInputAdapter_injectChar00(lua_State* tolua_S)
 
2804
{
 
2805
#ifndef TOLUA_RELEASE
 
2806
 tolua_Error tolua_err;
 
2807
 if (
 
2808
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
 
2809
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 
2810
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2811
 )
 
2812
  goto tolua_lerror;
 
2813
 else
 
2814
#endif
 
2815
 {
 
2816
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
 
2817
  char character = ((char)  tolua_tonumber(tolua_S,2,0));
 
2818
#ifndef TOLUA_RELEASE
 
2819
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectChar'",NULL);
 
2820
#endif
 
2821
  {
 
2822
   bool tolua_ret = (bool)  self->injectChar(character);
 
2823
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
2824
  }
 
2825
 }
 
2826
 return 1;
 
2827
#ifndef TOLUA_RELEASE
 
2828
 tolua_lerror:
 
2829
 tolua_error(tolua_S,"#ferror in function 'injectChar'.",&tolua_err);
 
2830
 return 0;
 
2831
#endif
 
2832
}
 
2833
#endif //#ifndef TOLUA_DISABLE
 
2834
 
 
2835
/* method: injectKeyDown of class  Ember::IInputAdapter */
 
2836
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectKeyDown00
 
2837
static int tolua_EmberServices_Ember_IInputAdapter_injectKeyDown00(lua_State* tolua_S)
 
2838
{
 
2839
#ifndef TOLUA_RELEASE
 
2840
 tolua_Error tolua_err;
 
2841
 if (
 
2842
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
 
2843
     !tolua_isusertype(tolua_S,2,"const SDLKey",0,&tolua_err) ||
 
2844
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2845
 )
 
2846
  goto tolua_lerror;
 
2847
 else
 
2848
#endif
 
2849
 {
 
2850
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
 
2851
  const SDLKey* key = ((const SDLKey*)  tolua_tousertype(tolua_S,2,0));
 
2852
#ifndef TOLUA_RELEASE
 
2853
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectKeyDown'",NULL);
 
2854
#endif
 
2855
  {
 
2856
   bool tolua_ret = (bool)  self->injectKeyDown(*key);
 
2857
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
2858
  }
 
2859
 }
 
2860
 return 1;
 
2861
#ifndef TOLUA_RELEASE
 
2862
 tolua_lerror:
 
2863
 tolua_error(tolua_S,"#ferror in function 'injectKeyDown'.",&tolua_err);
 
2864
 return 0;
 
2865
#endif
 
2866
}
 
2867
#endif //#ifndef TOLUA_DISABLE
 
2868
 
 
2869
/* method: injectKeyUp of class  Ember::IInputAdapter */
 
2870
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectKeyUp00
 
2871
static int tolua_EmberServices_Ember_IInputAdapter_injectKeyUp00(lua_State* tolua_S)
 
2872
{
 
2873
#ifndef TOLUA_RELEASE
 
2874
 tolua_Error tolua_err;
 
2875
 if (
 
2876
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
 
2877
     !tolua_isusertype(tolua_S,2,"const SDLKey",0,&tolua_err) ||
 
2878
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 
2879
 )
 
2880
  goto tolua_lerror;
 
2881
 else
 
2882
#endif
 
2883
 {
 
2884
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
 
2885
  const SDLKey* key = ((const SDLKey*)  tolua_tousertype(tolua_S,2,0));
 
2886
#ifndef TOLUA_RELEASE
 
2887
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectKeyUp'",NULL);
 
2888
#endif
 
2889
  {
 
2890
   bool tolua_ret = (bool)  self->injectKeyUp(*key);
 
2891
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
 
2892
  }
 
2893
 }
 
2894
 return 1;
 
2895
#ifndef TOLUA_RELEASE
 
2896
 tolua_lerror:
 
2897
 tolua_error(tolua_S,"#ferror in function 'injectKeyUp'.",&tolua_err);
 
2898
 return 0;
 
2899
#endif
 
2900
}
 
2901
#endif //#ifndef TOLUA_DISABLE
 
2902
 
 
2903
/* method: getSingleton of class  Ember::EmberServices */
 
2904
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getSingleton00
 
2905
static int tolua_EmberServices_Ember_EmberServices_getSingleton00(lua_State* tolua_S)
 
2906
{
 
2907
#ifndef TOLUA_RELEASE
 
2908
 tolua_Error tolua_err;
 
2909
 if (
 
2910
     !tolua_isusertable(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
 
2911
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2912
 )
 
2913
  goto tolua_lerror;
 
2914
 else
 
2915
#endif
 
2916
 {
 
2917
  {
 
2918
   Ember::EmberServices& tolua_ret = (Ember::EmberServices&)  Ember::EmberServices::getSingleton();
 
2919
   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::EmberServices");
 
2920
  }
 
2921
 }
 
2922
 return 1;
 
2923
#ifndef TOLUA_RELEASE
 
2924
 tolua_lerror:
 
2925
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 
2926
 return 0;
 
2927
#endif
 
2928
}
 
2929
#endif //#ifndef TOLUA_DISABLE
 
2930
 
 
2931
/* method: getLoggingService of class  Ember::EmberServices */
 
2932
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getLoggingService00
 
2933
static int tolua_EmberServices_Ember_EmberServices_getLoggingService00(lua_State* tolua_S)
 
2934
{
 
2935
#ifndef TOLUA_RELEASE
 
2936
 tolua_Error tolua_err;
 
2937
 if (
 
2938
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
 
2939
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2940
 )
 
2941
  goto tolua_lerror;
 
2942
 else
 
2943
#endif
 
2944
 {
 
2945
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
 
2946
#ifndef TOLUA_RELEASE
 
2947
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLoggingService'",NULL);
 
2948
#endif
 
2949
  {
 
2950
   Ember::LoggingService* tolua_ret = (Ember::LoggingService*)  self->getLoggingService();
 
2951
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::LoggingService");
 
2952
  }
 
2953
 }
 
2954
 return 1;
 
2955
#ifndef TOLUA_RELEASE
 
2956
 tolua_lerror:
 
2957
 tolua_error(tolua_S,"#ferror in function 'getLoggingService'.",&tolua_err);
 
2958
 return 0;
 
2959
#endif
 
2960
}
 
2961
#endif //#ifndef TOLUA_DISABLE
 
2962
 
 
2963
/* method: getConfigService of class  Ember::EmberServices */
 
2964
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getConfigService00
 
2965
static int tolua_EmberServices_Ember_EmberServices_getConfigService00(lua_State* tolua_S)
 
2966
{
 
2967
#ifndef TOLUA_RELEASE
 
2968
 tolua_Error tolua_err;
 
2969
 if (
 
2970
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
 
2971
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
2972
 )
 
2973
  goto tolua_lerror;
 
2974
 else
 
2975
#endif
 
2976
 {
 
2977
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
 
2978
#ifndef TOLUA_RELEASE
 
2979
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getConfigService'",NULL);
 
2980
#endif
 
2981
  {
 
2982
   Ember::ConfigService* tolua_ret = (Ember::ConfigService*)  self->getConfigService();
 
2983
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::ConfigService");
 
2984
  }
 
2985
 }
 
2986
 return 1;
 
2987
#ifndef TOLUA_RELEASE
 
2988
 tolua_lerror:
 
2989
 tolua_error(tolua_S,"#ferror in function 'getConfigService'.",&tolua_err);
 
2990
 return 0;
 
2991
#endif
 
2992
}
 
2993
#endif //#ifndef TOLUA_DISABLE
 
2994
 
 
2995
/* method: getMetaserverService of class  Ember::EmberServices */
 
2996
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getMetaserverService00
 
2997
static int tolua_EmberServices_Ember_EmberServices_getMetaserverService00(lua_State* tolua_S)
 
2998
{
 
2999
#ifndef TOLUA_RELEASE
 
3000
 tolua_Error tolua_err;
 
3001
 if (
 
3002
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
 
3003
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
3004
 )
 
3005
  goto tolua_lerror;
 
3006
 else
 
3007
#endif
 
3008
 {
 
3009
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
 
3010
#ifndef TOLUA_RELEASE
 
3011
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMetaserverService'",NULL);
 
3012
#endif
 
3013
  {
 
3014
   Ember::MetaserverService* tolua_ret = (Ember::MetaserverService*)  self->getMetaserverService();
 
3015
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::MetaserverService");
 
3016
  }
 
3017
 }
 
3018
 return 1;
 
3019
#ifndef TOLUA_RELEASE
 
3020
 tolua_lerror:
 
3021
 tolua_error(tolua_S,"#ferror in function 'getMetaserverService'.",&tolua_err);
 
3022
 return 0;
 
3023
#endif
 
3024
}
 
3025
#endif //#ifndef TOLUA_DISABLE
 
3026
 
 
3027
/* method: getServerService of class  Ember::EmberServices */
 
3028
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getServerService00
 
3029
static int tolua_EmberServices_Ember_EmberServices_getServerService00(lua_State* tolua_S)
 
3030
{
 
3031
#ifndef TOLUA_RELEASE
 
3032
 tolua_Error tolua_err;
 
3033
 if (
 
3034
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
 
3035
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
3036
 )
 
3037
  goto tolua_lerror;
 
3038
 else
 
3039
#endif
 
3040
 {
 
3041
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
 
3042
#ifndef TOLUA_RELEASE
 
3043
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getServerService'",NULL);
 
3044
#endif
 
3045
  {
 
3046
   Ember::ServerService* tolua_ret = (Ember::ServerService*)  self->getServerService();
 
3047
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::ServerService");
 
3048
  }
 
3049
 }
 
3050
 return 1;
 
3051
#ifndef TOLUA_RELEASE
 
3052
 tolua_lerror:
 
3053
 tolua_error(tolua_S,"#ferror in function 'getServerService'.",&tolua_err);
 
3054
 return 0;
 
3055
#endif
 
3056
}
 
3057
#endif //#ifndef TOLUA_DISABLE
 
3058
 
 
3059
/* method: getScriptingService of class  Ember::EmberServices */
 
3060
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getScriptingService00
 
3061
static int tolua_EmberServices_Ember_EmberServices_getScriptingService00(lua_State* tolua_S)
 
3062
{
 
3063
#ifndef TOLUA_RELEASE
 
3064
 tolua_Error tolua_err;
 
3065
 if (
 
3066
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
 
3067
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 
3068
 )
 
3069
  goto tolua_lerror;
 
3070
 else
 
3071
#endif
 
3072
 {
 
3073
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
 
3074
#ifndef TOLUA_RELEASE
 
3075
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScriptingService'",NULL);
 
3076
#endif
 
3077
  {
 
3078
   Ember::ScriptingService* tolua_ret = (Ember::ScriptingService*)  self->getScriptingService();
 
3079
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::ScriptingService");
 
3080
  }
 
3081
 }
 
3082
 return 1;
 
3083
#ifndef TOLUA_RELEASE
 
3084
 tolua_lerror:
 
3085
 tolua_error(tolua_S,"#ferror in function 'getScriptingService'.",&tolua_err);
 
3086
 return 0;
 
3087
#endif
 
3088
}
 
3089
#endif //#ifndef TOLUA_DISABLE
 
3090
 
 
3091
/* Open function */
 
3092
TOLUA_API int tolua_EmberServices_open (lua_State* tolua_S)
 
3093
{
 
3094
 tolua_open(tolua_S);
 
3095
 tolua_reg_types(tolua_S);
 
3096
 tolua_module(tolua_S,NULL,0);
 
3097
 tolua_beginmodule(tolua_S,NULL);
 
3098
  tolua_module(tolua_S,"Ember",0);
 
3099
  tolua_beginmodule(tolua_S,"Ember");
 
3100
   tolua_cclass(tolua_S,"MouseMotion","Ember::MouseMotion","",NULL);
 
3101
   tolua_beginmodule(tolua_S,"MouseMotion");
 
3102
    tolua_variable(tolua_S,"xPosition",tolua_get_Ember__MouseMotion_xPosition,tolua_set_Ember__MouseMotion_xPosition);
 
3103
    tolua_variable(tolua_S,"yPosition",tolua_get_Ember__MouseMotion_yPosition,tolua_set_Ember__MouseMotion_yPosition);
 
3104
    tolua_variable(tolua_S,"xRelativeMovement",tolua_get_Ember__MouseMotion_xRelativeMovement,tolua_set_Ember__MouseMotion_xRelativeMovement);
 
3105
    tolua_variable(tolua_S,"yRelativeMovement",tolua_get_Ember__MouseMotion_yRelativeMovement,tolua_set_Ember__MouseMotion_yRelativeMovement);
 
3106
    tolua_variable(tolua_S,"xRelativeMovementInPixels",tolua_get_Ember__MouseMotion_xRelativeMovementInPixels,tolua_set_Ember__MouseMotion_xRelativeMovementInPixels);
 
3107
    tolua_variable(tolua_S,"yRelativeMovementInPixels",tolua_get_Ember__MouseMotion_yRelativeMovementInPixels,tolua_set_Ember__MouseMotion_yRelativeMovementInPixels);
 
3108
    tolua_variable(tolua_S,"timeSinceLastMovement",tolua_get_Ember__MouseMotion_timeSinceLastMovement,tolua_set_Ember__MouseMotion_timeSinceLastMovement);
 
3109
   tolua_endmodule(tolua_S);
 
3110
   tolua_cclass(tolua_S,"Input","Ember::Input","",NULL);
 
3111
   tolua_beginmodule(tolua_S,"Input");
 
3112
    tolua_function(tolua_S,"getSingleton",tolua_EmberServices_Ember_Input_getSingleton00);
 
3113
    tolua_constant(tolua_S,"MouseButtonLeft",Ember::Input::MouseButtonLeft);
 
3114
    tolua_constant(tolua_S,"MouseButtonRight",Ember::Input::MouseButtonRight);
 
3115
    tolua_constant(tolua_S,"MouseButtonMiddle",Ember::Input::MouseButtonMiddle);
 
3116
    tolua_constant(tolua_S,"IM_GUI",Ember::Input::IM_GUI);
 
3117
    tolua_constant(tolua_S,"IM_MOVEMENT",Ember::Input::IM_MOVEMENT);
 
3118
    tolua_variable(tolua_S,"EventKeyPressed",tolua_get_Ember__Input_EventKeyPressed,tolua_set_Ember__Input_EventKeyPressed);
 
3119
    tolua_variable(tolua_S,"EventKeyReleased",tolua_get_Ember__Input_EventKeyReleased,tolua_set_Ember__Input_EventKeyReleased);
 
3120
    tolua_variable(tolua_S,"EventMouseMoved",tolua_get_Ember__Input_EventMouseMoved,tolua_set_Ember__Input_EventMouseMoved);
 
3121
    tolua_variable(tolua_S,"EventMouseButtonPressed",tolua_get_Ember__Input_EventMouseButtonPressed,tolua_set_Ember__Input_EventMouseButtonPressed);
 
3122
    tolua_variable(tolua_S,"EventMouseButtonReleased",tolua_get_Ember__Input_EventMouseButtonReleased,tolua_set_Ember__Input_EventMouseButtonReleased);
 
3123
    tolua_variable(tolua_S,"EventChangedInputMode",tolua_get_Ember__Input_EventChangedInputMode,tolua_set_Ember__Input_EventChangedInputMode);
 
3124
    tolua_function(tolua_S,"isKeyDown",tolua_EmberServices_Ember_Input_isKeyDown00);
 
3125
    tolua_function(tolua_S,"setInputMode",tolua_EmberServices_Ember_Input_setInputMode00);
 
3126
    tolua_function(tolua_S,"getInputMode",tolua_EmberServices_Ember_Input_getInputMode00);
 
3127
    tolua_function(tolua_S,"toggleInputMode",tolua_EmberServices_Ember_Input_toggleInputMode00);
 
3128
    tolua_function(tolua_S,"addAdapter",tolua_EmberServices_Ember_Input_addAdapter00);
 
3129
    tolua_function(tolua_S,"removeAdapter",tolua_EmberServices_Ember_Input_removeAdapter00);
 
3130
   tolua_endmodule(tolua_S);
 
3131
  tolua_endmodule(tolua_S);
 
3132
  tolua_module(tolua_S,"Ember",0);
 
3133
  tolua_beginmodule(tolua_S,"Ember");
 
3134
   tolua_cclass(tolua_S,"LoggingService","Ember::LoggingService","",NULL);
 
3135
   tolua_beginmodule(tolua_S,"LoggingService");
 
3136
   tolua_endmodule(tolua_S);
 
3137
  tolua_endmodule(tolua_S);
 
3138
  tolua_module(tolua_S,"Ember",0);
 
3139
  tolua_beginmodule(tolua_S,"Ember");
 
3140
   tolua_cclass(tolua_S,"ConfigService","Ember::ConfigService","",NULL);
 
3141
   tolua_beginmodule(tolua_S,"ConfigService");
 
3142
    tolua_variable(tolua_S,"SETVALUE",tolua_get_Ember__ConfigService_SETVALUE,NULL);
 
3143
    tolua_variable(tolua_S,"GETVALUE",tolua_get_Ember__ConfigService_GETVALUE,NULL);
 
3144
    tolua_function(tolua_S,"getValue",tolua_EmberServices_Ember_ConfigService_getValue00);
 
3145
    tolua_function(tolua_S,"setValue",tolua_EmberServices_Ember_ConfigService_setValue00);
 
3146
    tolua_function(tolua_S,"isItemSet",tolua_EmberServices_Ember_ConfigService_isItemSet00);
 
3147
    tolua_function(tolua_S,"itemExists",tolua_EmberServices_Ember_ConfigService_itemExists00);
 
3148
    tolua_function(tolua_S,"deleteItem",tolua_EmberServices_Ember_ConfigService_deleteItem00);
 
3149
    tolua_function(tolua_S,"loadSavedConfig",tolua_EmberServices_Ember_ConfigService_loadSavedConfig00);
 
3150
    tolua_function(tolua_S,"saveConfig",tolua_EmberServices_Ember_ConfigService_saveConfig00);
 
3151
    tolua_function(tolua_S,"getHomeDirectory",tolua_EmberServices_Ember_ConfigService_getHomeDirectory00);
 
3152
    tolua_function(tolua_S,"getSharedDataDirectory",tolua_EmberServices_Ember_ConfigService_getSharedDataDirectory00);
 
3153
    tolua_function(tolua_S,"getEmberDataDirectory",tolua_EmberServices_Ember_ConfigService_getEmberDataDirectory00);
 
3154
    tolua_function(tolua_S,"getEmberMediaDirectory",tolua_EmberServices_Ember_ConfigService_getEmberMediaDirectory00);
 
3155
    tolua_function(tolua_S,"getUserMediaDirectory",tolua_EmberServices_Ember_ConfigService_getUserMediaDirectory00);
 
3156
    tolua_function(tolua_S,"getSharedMediaDirectory",tolua_EmberServices_Ember_ConfigService_getSharedMediaDirectory00);
 
3157
    tolua_function(tolua_S,"getSharedConfigDirectory",tolua_EmberServices_Ember_ConfigService_getSharedConfigDirectory00);
 
3158
    tolua_variable(tolua_S,"EventChangedConfigItem",tolua_get_Ember__ConfigService_EventChangedConfigItem,tolua_set_Ember__ConfigService_EventChangedConfigItem);
 
3159
   tolua_endmodule(tolua_S);
 
3160
  tolua_endmodule(tolua_S);
 
3161
  tolua_module(tolua_S,"Ember",0);
 
3162
  tolua_beginmodule(tolua_S,"Ember");
 
3163
   tolua_cclass(tolua_S,"MetaserverService","Ember::MetaserverService","",NULL);
 
3164
   tolua_beginmodule(tolua_S,"MetaserverService");
 
3165
    tolua_function(tolua_S,"getMetaServer",tolua_EmberServices_Ember_MetaserverService_getMetaServer00);
 
3166
   tolua_endmodule(tolua_S);
 
3167
  tolua_endmodule(tolua_S);
 
3168
  tolua_module(tolua_S,"Ember",0);
 
3169
  tolua_beginmodule(tolua_S,"Ember");
 
3170
   tolua_cclass(tolua_S,"ServerService","Ember::ServerService","",NULL);
 
3171
   tolua_beginmodule(tolua_S,"ServerService");
 
3172
    tolua_function(tolua_S,"isConnected",tolua_EmberServices_Ember_ServerService_isConnected00);
 
3173
    tolua_function(tolua_S,"connect",tolua_EmberServices_Ember_ServerService_connect00);
 
3174
    tolua_function(tolua_S,"disconnect",tolua_EmberServices_Ember_ServerService_disconnect00);
 
3175
    tolua_function(tolua_S,"takeCharacter",tolua_EmberServices_Ember_ServerService_takeCharacter00);
 
3176
    tolua_function(tolua_S,"createCharacter",tolua_EmberServices_Ember_ServerService_createCharacter00);
 
3177
    tolua_function(tolua_S,"moveToPoint",tolua_EmberServices_Ember_ServerService_moveToPoint00);
 
3178
    tolua_function(tolua_S,"moveInDirection",tolua_EmberServices_Ember_ServerService_moveInDirection00);
 
3179
    tolua_function(tolua_S,"moveInDirection",tolua_EmberServices_Ember_ServerService_moveInDirection01);
 
3180
    tolua_function(tolua_S,"say",tolua_EmberServices_Ember_ServerService_say00);
 
3181
    tolua_function(tolua_S,"touch",tolua_EmberServices_Ember_ServerService_touch00);
 
3182
    tolua_function(tolua_S,"emote",tolua_EmberServices_Ember_ServerService_emote00);
 
3183
    tolua_function(tolua_S,"drop",tolua_EmberServices_Ember_ServerService_drop00);
 
3184
    tolua_function(tolua_S,"drop",tolua_EmberServices_Ember_ServerService_drop01);
 
3185
    tolua_function(tolua_S,"place",tolua_EmberServices_Ember_ServerService_place00);
 
3186
    tolua_function(tolua_S,"wield",tolua_EmberServices_Ember_ServerService_wield00);
 
3187
    tolua_function(tolua_S,"take",tolua_EmberServices_Ember_ServerService_take00);
 
3188
    tolua_function(tolua_S,"use",tolua_EmberServices_Ember_ServerService_use00);
 
3189
    tolua_function(tolua_S,"use",tolua_EmberServices_Ember_ServerService_use01);
 
3190
    tolua_function(tolua_S,"use",tolua_EmberServices_Ember_ServerService_use02);
 
3191
    tolua_function(tolua_S,"useStop",tolua_EmberServices_Ember_ServerService_useStop00);
 
3192
    tolua_function(tolua_S,"actuate",tolua_EmberServices_Ember_ServerService_actuate00);
 
3193
    tolua_function(tolua_S,"attack",tolua_EmberServices_Ember_ServerService_attack00);
 
3194
    tolua_function(tolua_S,"eat",tolua_EmberServices_Ember_ServerService_eat00);
 
3195
    tolua_function(tolua_S,"deleteEntity",tolua_EmberServices_Ember_ServerService_deleteEntity00);
 
3196
    tolua_function(tolua_S,"setAttributes",tolua_EmberServices_Ember_ServerService_setAttributes00);
 
3197
    tolua_variable(tolua_S,"GotAvatar",tolua_get_Ember__ServerService_GotAvatar,tolua_set_Ember__ServerService_GotAvatar);
 
3198
    tolua_variable(tolua_S,"GotView",tolua_get_Ember__ServerService_GotView,tolua_set_Ember__ServerService_GotView);
 
3199
    tolua_variable(tolua_S,"GotConnection",tolua_get_Ember__ServerService_GotConnection,tolua_set_Ember__ServerService_GotConnection);
 
3200
    tolua_variable(tolua_S,"GotAccount",tolua_get_Ember__ServerService_GotAccount,tolua_set_Ember__ServerService_GotAccount);
 
3201
    tolua_variable(tolua_S,"LoginSuccess",tolua_get_Ember__ServerService_LoginSuccess,tolua_set_Ember__ServerService_LoginSuccess);
 
3202
    tolua_variable(tolua_S,"LoginFailure",tolua_get_Ember__ServerService_LoginFailure,tolua_set_Ember__ServerService_LoginFailure);
 
3203
    tolua_variable(tolua_S,"GotCharacterInfo",tolua_get_Ember__ServerService_GotCharacterInfo,tolua_set_Ember__ServerService_GotCharacterInfo);
 
3204
    tolua_variable(tolua_S,"GotAllCharacters",tolua_get_Ember__ServerService_GotAllCharacters,tolua_set_Ember__ServerService_GotAllCharacters);
 
3205
   tolua_endmodule(tolua_S);
 
3206
  tolua_endmodule(tolua_S);
 
3207
  tolua_module(tolua_S,"Ember",0);
 
3208
  tolua_beginmodule(tolua_S,"Ember");
 
3209
   tolua_cclass(tolua_S,"ScriptingService","Ember::ScriptingService","",NULL);
 
3210
   tolua_beginmodule(tolua_S,"ScriptingService");
 
3211
    tolua_function(tolua_S,"registerScriptingProvider",tolua_EmberServices_Ember_ScriptingService_registerScriptingProvider00);
 
3212
    tolua_function(tolua_S,"loadScript",tolua_EmberServices_Ember_ScriptingService_loadScript00);
 
3213
    tolua_function(tolua_S,"executeCode",tolua_EmberServices_Ember_ScriptingService_executeCode00);
 
3214
    tolua_function(tolua_S,"getEventScriptError",tolua_EmberServices_Ember_ScriptingService_getEventScriptError00);
 
3215
    tolua_function(tolua_S,"getProviderFor",tolua_EmberServices_Ember_ScriptingService_getProviderFor00);
 
3216
    tolua_function(tolua_S,"getProviderNames",tolua_EmberServices_Ember_ScriptingService_getProviderNames00);
 
3217
    tolua_function(tolua_S,"getAlwaysLookup",tolua_EmberServices_Ember_ScriptingService_getAlwaysLookup00);
 
3218
    tolua_function(tolua_S,"setAlwaysLookup",tolua_EmberServices_Ember_ScriptingService_setAlwaysLookup00);
 
3219
   tolua_endmodule(tolua_S);
 
3220
  tolua_endmodule(tolua_S);
 
3221
  tolua_module(tolua_S,"Ember",0);
 
3222
  tolua_beginmodule(tolua_S,"Ember");
 
3223
   tolua_cclass(tolua_S,"InputService","Ember::InputService","",NULL);
 
3224
   tolua_beginmodule(tolua_S,"InputService");
 
3225
    tolua_function(tolua_S,"getInput",tolua_EmberServices_Ember_InputService_getInput00);
 
3226
   tolua_endmodule(tolua_S);
 
3227
  tolua_endmodule(tolua_S);
 
3228
  tolua_module(tolua_S,"Ember",0);
 
3229
  tolua_beginmodule(tolua_S,"Ember");
 
3230
   #ifdef __cplusplus
 
3231
   tolua_cclass(tolua_S,"IInputAdapter","Ember::IInputAdapter","",tolua_collect_Ember__IInputAdapter);
 
3232
   #else
 
3233
   tolua_cclass(tolua_S,"IInputAdapter","Ember::IInputAdapter","",NULL);
 
3234
   #endif
 
3235
   tolua_beginmodule(tolua_S,"IInputAdapter");
 
3236
    tolua_function(tolua_S,"delete",tolua_EmberServices_Ember_IInputAdapter_delete00);
 
3237
    tolua_function(tolua_S,"injectMouseMove",tolua_EmberServices_Ember_IInputAdapter_injectMouseMove00);
 
3238
    tolua_function(tolua_S,"injectMouseButtonUp",tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonUp00);
 
3239
    tolua_function(tolua_S,"injectMouseButtonDown",tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonDown00);
 
3240
    tolua_function(tolua_S,"injectChar",tolua_EmberServices_Ember_IInputAdapter_injectChar00);
 
3241
    tolua_function(tolua_S,"injectKeyDown",tolua_EmberServices_Ember_IInputAdapter_injectKeyDown00);
 
3242
    tolua_function(tolua_S,"injectKeyUp",tolua_EmberServices_Ember_IInputAdapter_injectKeyUp00);
 
3243
   tolua_endmodule(tolua_S);
 
3244
  tolua_endmodule(tolua_S);
 
3245
  tolua_module(tolua_S,"Ember",0);
 
3246
  tolua_beginmodule(tolua_S,"Ember");
 
3247
   tolua_cclass(tolua_S,"EmberServices","Ember::EmberServices","",NULL);
 
3248
   tolua_beginmodule(tolua_S,"EmberServices");
 
3249
    tolua_function(tolua_S,"getSingleton",tolua_EmberServices_Ember_EmberServices_getSingleton00);
 
3250
    tolua_function(tolua_S,"getLoggingService",tolua_EmberServices_Ember_EmberServices_getLoggingService00);
 
3251
    tolua_function(tolua_S,"getConfigService",tolua_EmberServices_Ember_EmberServices_getConfigService00);
 
3252
    tolua_function(tolua_S,"getMetaserverService",tolua_EmberServices_Ember_EmberServices_getMetaserverService00);
 
3253
    tolua_function(tolua_S,"getServerService",tolua_EmberServices_Ember_EmberServices_getServerService00);
 
3254
    tolua_function(tolua_S,"getScriptingService",tolua_EmberServices_Ember_EmberServices_getScriptingService00);
 
3255
   tolua_endmodule(tolua_S);
 
3256
  tolua_endmodule(tolua_S);
 
3257
 tolua_endmodule(tolua_S);
 
3258
 return 1;
 
3259
}
 
3260
 
 
3261
 
 
3262
#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 
3263
 TOLUA_API int luaopen_EmberServices (lua_State* tolua_S) {
 
3264
 return tolua_EmberServices_open(tolua_S);
 
3265
};
 
3266
#endif
 
3267