PanTiltInterface_tolua.cpp

00001 /*
00002 ** Lua binding: interfaces_PanTiltInterface
00003 ** Generated automatically by tolua++-1.0.92
00004 */
00005 /*  This program is free software; you can redistribute it and/or modify
00006  *  it under the terms of the GNU General Public License as published by
00007  *  the Free Software Foundation; either version 2 of the License, or
00008  *  (at your option) any later version. A runtime exception applies to
00009  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00010  *
00011  *  This program is distributed in the hope that it will be useful,
00012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  *  GNU Library General Public License for more details.
00015  *
00016  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00017  */
00018 
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023 
00024 #include "tolua++.h"
00025 
00026 /* Exported function */
00027 TOLUA_API int  tolua_interfaces_PanTiltInterface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/PanTiltInterface.h>
00030 using namespace fawkes;
00031 
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__PanTiltInterface__TimedGotoMessage (lua_State* tolua_S)
00036 {
00037  fawkes::PanTiltInterface::TimedGotoMessage* self = (fawkes::PanTiltInterface::TimedGotoMessage*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 
00042 static int tolua_collect_fawkes__PanTiltInterface__GotoMessage (lua_State* tolua_S)
00043 {
00044  fawkes::PanTiltInterface::GotoMessage* self = (fawkes::PanTiltInterface::GotoMessage*) tolua_tousertype(tolua_S,1,0);
00045         Mtolua_delete(self);
00046         return 0;
00047 }
00048 
00049 static int tolua_collect_fawkes__PanTiltInterface__FlushMessage (lua_State* tolua_S)
00050 {
00051  fawkes::PanTiltInterface::FlushMessage* self = (fawkes::PanTiltInterface::FlushMessage*) tolua_tousertype(tolua_S,1,0);
00052         Mtolua_delete(self);
00053         return 0;
00054 }
00055 
00056 static int tolua_collect_fawkes__PanTiltInterface__SetMarginMessage (lua_State* tolua_S)
00057 {
00058  fawkes::PanTiltInterface::SetMarginMessage* self = (fawkes::PanTiltInterface::SetMarginMessage*) tolua_tousertype(tolua_S,1,0);
00059         Mtolua_delete(self);
00060         return 0;
00061 }
00062 
00063 static int tolua_collect_fawkes__PanTiltInterface__ParkMessage (lua_State* tolua_S)
00064 {
00065  fawkes::PanTiltInterface::ParkMessage* self = (fawkes::PanTiltInterface::ParkMessage*) tolua_tousertype(tolua_S,1,0);
00066         Mtolua_delete(self);
00067         return 0;
00068 }
00069 
00070 static int tolua_collect_fawkes__PanTiltInterface__StopMessage (lua_State* tolua_S)
00071 {
00072  fawkes::PanTiltInterface::StopMessage* self = (fawkes::PanTiltInterface::StopMessage*) tolua_tousertype(tolua_S,1,0);
00073         Mtolua_delete(self);
00074         return 0;
00075 }
00076 
00077 static int tolua_collect_fawkes__PanTiltInterface__SetEnabledMessage (lua_State* tolua_S)
00078 {
00079  fawkes::PanTiltInterface::SetEnabledMessage* self = (fawkes::PanTiltInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0);
00080         Mtolua_delete(self);
00081         return 0;
00082 }
00083 
00084 static int tolua_collect_fawkes__PanTiltInterface__SetVelocityMessage (lua_State* tolua_S)
00085 {
00086  fawkes::PanTiltInterface::SetVelocityMessage* self = (fawkes::PanTiltInterface::SetVelocityMessage*) tolua_tousertype(tolua_S,1,0);
00087         Mtolua_delete(self);
00088         return 0;
00089 }
00090 
00091 static int tolua_collect_fawkes__PanTiltInterface__CalibrateMessage (lua_State* tolua_S)
00092 {
00093  fawkes::PanTiltInterface::CalibrateMessage* self = (fawkes::PanTiltInterface::CalibrateMessage*) tolua_tousertype(tolua_S,1,0);
00094         Mtolua_delete(self);
00095         return 0;
00096 }
00097 #endif
00098 
00099 
00100 /* function to register type */
00101 static void tolua_reg_types (lua_State* tolua_S)
00102 {
00103  tolua_usertype(tolua_S,"fawkes::PanTiltInterface::ParkMessage");
00104  tolua_usertype(tolua_S,"fawkes::PanTiltInterface::GotoMessage");
00105  tolua_usertype(tolua_S,"fawkes::PanTiltInterface::FlushMessage");
00106  tolua_usertype(tolua_S,"fawkes::PanTiltInterface");
00107  tolua_usertype(tolua_S,"Message");
00108  tolua_usertype(tolua_S,"fawkes::PanTiltInterface::SetMarginMessage");
00109  tolua_usertype(tolua_S,"fawkes::PanTiltInterface::CalibrateMessage");
00110  tolua_usertype(tolua_S,"fawkes::PanTiltInterface::StopMessage");
00111  tolua_usertype(tolua_S,"fawkes::PanTiltInterface::TimedGotoMessage");
00112  tolua_usertype(tolua_S,"fawkes::PanTiltInterface::SetEnabledMessage");
00113  tolua_usertype(tolua_S,"fawkes::PanTiltInterface::SetVelocityMessage");
00114  tolua_usertype(tolua_S,"Interface");
00115 }
00116 
00117 /* get function: FLAG_SUPPORTS_PAN of class  fawkes::PanTiltInterface */
00118 #ifndef TOLUA_DISABLE_tolua_get_fawkes__PanTiltInterface_unsigned_FLAG_SUPPORTS_PAN
00119 static int tolua_get_fawkes__PanTiltInterface_unsigned_FLAG_SUPPORTS_PAN(lua_State* tolua_S)
00120 {
00121   tolua_pushnumber(tolua_S,(lua_Number)fawkes::PanTiltInterface::FLAG_SUPPORTS_PAN);
00122  return 1;
00123 }
00124 #endif //#ifndef TOLUA_DISABLE
00125 
00126 /* get function: FLAG_SUPPORTS_TILT of class  fawkes::PanTiltInterface */
00127 #ifndef TOLUA_DISABLE_tolua_get_fawkes__PanTiltInterface_unsigned_FLAG_SUPPORTS_TILT
00128 static int tolua_get_fawkes__PanTiltInterface_unsigned_FLAG_SUPPORTS_TILT(lua_State* tolua_S)
00129 {
00130   tolua_pushnumber(tolua_S,(lua_Number)fawkes::PanTiltInterface::FLAG_SUPPORTS_TILT);
00131  return 1;
00132 }
00133 #endif //#ifndef TOLUA_DISABLE
00134 
00135 /* get function: ERROR_NONE of class  fawkes::PanTiltInterface */
00136 #ifndef TOLUA_DISABLE_tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_NONE
00137 static int tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_NONE(lua_State* tolua_S)
00138 {
00139   tolua_pushnumber(tolua_S,(lua_Number)fawkes::PanTiltInterface::ERROR_NONE);
00140  return 1;
00141 }
00142 #endif //#ifndef TOLUA_DISABLE
00143 
00144 /* get function: ERROR_UNSPECIFIC of class  fawkes::PanTiltInterface */
00145 #ifndef TOLUA_DISABLE_tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_UNSPECIFIC
00146 static int tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_UNSPECIFIC(lua_State* tolua_S)
00147 {
00148   tolua_pushnumber(tolua_S,(lua_Number)fawkes::PanTiltInterface::ERROR_UNSPECIFIC);
00149  return 1;
00150 }
00151 #endif //#ifndef TOLUA_DISABLE
00152 
00153 /* get function: ERROR_COMMUNICATION of class  fawkes::PanTiltInterface */
00154 #ifndef TOLUA_DISABLE_tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_COMMUNICATION
00155 static int tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_COMMUNICATION(lua_State* tolua_S)
00156 {
00157   tolua_pushnumber(tolua_S,(lua_Number)fawkes::PanTiltInterface::ERROR_COMMUNICATION);
00158  return 1;
00159 }
00160 #endif //#ifndef TOLUA_DISABLE
00161 
00162 /* get function: ERROR_PAN_OUTOFRANGE of class  fawkes::PanTiltInterface */
00163 #ifndef TOLUA_DISABLE_tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_PAN_OUTOFRANGE
00164 static int tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_PAN_OUTOFRANGE(lua_State* tolua_S)
00165 {
00166   tolua_pushnumber(tolua_S,(lua_Number)fawkes::PanTiltInterface::ERROR_PAN_OUTOFRANGE);
00167  return 1;
00168 }
00169 #endif //#ifndef TOLUA_DISABLE
00170 
00171 /* get function: ERROR_TILT_OUTOFRANGE of class  fawkes::PanTiltInterface */
00172 #ifndef TOLUA_DISABLE_tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_TILT_OUTOFRANGE
00173 static int tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_TILT_OUTOFRANGE(lua_State* tolua_S)
00174 {
00175   tolua_pushnumber(tolua_S,(lua_Number)fawkes::PanTiltInterface::ERROR_TILT_OUTOFRANGE);
00176  return 1;
00177 }
00178 #endif //#ifndef TOLUA_DISABLE
00179 
00180 /* method: new of class  StopMessage */
00181 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_new00
00182 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_new00(lua_State* tolua_S)
00183 {
00184 #ifndef TOLUA_RELEASE
00185  tolua_Error tolua_err;
00186  if (
00187      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::StopMessage",0,&tolua_err) ||
00188      !tolua_isnoobj(tolua_S,2,&tolua_err)
00189  )
00190   goto tolua_lerror;
00191  else
00192 #endif
00193  {
00194   {
00195    fawkes::PanTiltInterface::StopMessage* tolua_ret = (fawkes::PanTiltInterface::StopMessage*)  Mtolua_new((fawkes::PanTiltInterface::StopMessage)());
00196     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::StopMessage");
00197   }
00198  }
00199  return 1;
00200 #ifndef TOLUA_RELEASE
00201  tolua_lerror:
00202  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00203  return 0;
00204 #endif
00205 }
00206 #endif //#ifndef TOLUA_DISABLE
00207 
00208 /* method: new_local of class  StopMessage */
00209 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_new00_local
00210 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_new00_local(lua_State* tolua_S)
00211 {
00212 #ifndef TOLUA_RELEASE
00213  tolua_Error tolua_err;
00214  if (
00215      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::StopMessage",0,&tolua_err) ||
00216      !tolua_isnoobj(tolua_S,2,&tolua_err)
00217  )
00218   goto tolua_lerror;
00219  else
00220 #endif
00221  {
00222   {
00223    fawkes::PanTiltInterface::StopMessage* tolua_ret = (fawkes::PanTiltInterface::StopMessage*)  Mtolua_new((fawkes::PanTiltInterface::StopMessage)());
00224     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::StopMessage");
00225     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00226   }
00227  }
00228  return 1;
00229 #ifndef TOLUA_RELEASE
00230  tolua_lerror:
00231  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00232  return 0;
00233 #endif
00234 }
00235 #endif //#ifndef TOLUA_DISABLE
00236 
00237 /* method: delete of class  StopMessage */
00238 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_delete00
00239 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_delete00(lua_State* tolua_S)
00240 {
00241 #ifndef TOLUA_RELEASE
00242  tolua_Error tolua_err;
00243  if (
00244      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::StopMessage",0,&tolua_err) ||
00245      !tolua_isnoobj(tolua_S,2,&tolua_err)
00246  )
00247   goto tolua_lerror;
00248  else
00249 #endif
00250  {
00251   fawkes::PanTiltInterface::StopMessage* self = (fawkes::PanTiltInterface::StopMessage*)  tolua_tousertype(tolua_S,1,0);
00252 #ifndef TOLUA_RELEASE
00253   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00254 #endif
00255   Mtolua_delete(self);
00256  }
00257  return 0;
00258 #ifndef TOLUA_RELEASE
00259  tolua_lerror:
00260  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00261  return 0;
00262 #endif
00263 }
00264 #endif //#ifndef TOLUA_DISABLE
00265 
00266 /* method: new of class  FlushMessage */
00267 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_new00
00268 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_new00(lua_State* tolua_S)
00269 {
00270 #ifndef TOLUA_RELEASE
00271  tolua_Error tolua_err;
00272  if (
00273      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::FlushMessage",0,&tolua_err) ||
00274      !tolua_isnoobj(tolua_S,2,&tolua_err)
00275  )
00276   goto tolua_lerror;
00277  else
00278 #endif
00279  {
00280   {
00281    fawkes::PanTiltInterface::FlushMessage* tolua_ret = (fawkes::PanTiltInterface::FlushMessage*)  Mtolua_new((fawkes::PanTiltInterface::FlushMessage)());
00282     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::FlushMessage");
00283   }
00284  }
00285  return 1;
00286 #ifndef TOLUA_RELEASE
00287  tolua_lerror:
00288  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00289  return 0;
00290 #endif
00291 }
00292 #endif //#ifndef TOLUA_DISABLE
00293 
00294 /* method: new_local of class  FlushMessage */
00295 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_new00_local
00296 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_new00_local(lua_State* tolua_S)
00297 {
00298 #ifndef TOLUA_RELEASE
00299  tolua_Error tolua_err;
00300  if (
00301      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::FlushMessage",0,&tolua_err) ||
00302      !tolua_isnoobj(tolua_S,2,&tolua_err)
00303  )
00304   goto tolua_lerror;
00305  else
00306 #endif
00307  {
00308   {
00309    fawkes::PanTiltInterface::FlushMessage* tolua_ret = (fawkes::PanTiltInterface::FlushMessage*)  Mtolua_new((fawkes::PanTiltInterface::FlushMessage)());
00310     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::FlushMessage");
00311     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00312   }
00313  }
00314  return 1;
00315 #ifndef TOLUA_RELEASE
00316  tolua_lerror:
00317  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00318  return 0;
00319 #endif
00320 }
00321 #endif //#ifndef TOLUA_DISABLE
00322 
00323 /* method: delete of class  FlushMessage */
00324 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_delete00
00325 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_delete00(lua_State* tolua_S)
00326 {
00327 #ifndef TOLUA_RELEASE
00328  tolua_Error tolua_err;
00329  if (
00330      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::FlushMessage",0,&tolua_err) ||
00331      !tolua_isnoobj(tolua_S,2,&tolua_err)
00332  )
00333   goto tolua_lerror;
00334  else
00335 #endif
00336  {
00337   fawkes::PanTiltInterface::FlushMessage* self = (fawkes::PanTiltInterface::FlushMessage*)  tolua_tousertype(tolua_S,1,0);
00338 #ifndef TOLUA_RELEASE
00339   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00340 #endif
00341   Mtolua_delete(self);
00342  }
00343  return 0;
00344 #ifndef TOLUA_RELEASE
00345  tolua_lerror:
00346  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00347  return 0;
00348 #endif
00349 }
00350 #endif //#ifndef TOLUA_DISABLE
00351 
00352 /* method: new of class  CalibrateMessage */
00353 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_new00
00354 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_new00(lua_State* tolua_S)
00355 {
00356 #ifndef TOLUA_RELEASE
00357  tolua_Error tolua_err;
00358  if (
00359      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::CalibrateMessage",0,&tolua_err) ||
00360      !tolua_isnoobj(tolua_S,2,&tolua_err)
00361  )
00362   goto tolua_lerror;
00363  else
00364 #endif
00365  {
00366   {
00367    fawkes::PanTiltInterface::CalibrateMessage* tolua_ret = (fawkes::PanTiltInterface::CalibrateMessage*)  Mtolua_new((fawkes::PanTiltInterface::CalibrateMessage)());
00368     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::CalibrateMessage");
00369   }
00370  }
00371  return 1;
00372 #ifndef TOLUA_RELEASE
00373  tolua_lerror:
00374  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00375  return 0;
00376 #endif
00377 }
00378 #endif //#ifndef TOLUA_DISABLE
00379 
00380 /* method: new_local of class  CalibrateMessage */
00381 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_new00_local
00382 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_new00_local(lua_State* tolua_S)
00383 {
00384 #ifndef TOLUA_RELEASE
00385  tolua_Error tolua_err;
00386  if (
00387      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::CalibrateMessage",0,&tolua_err) ||
00388      !tolua_isnoobj(tolua_S,2,&tolua_err)
00389  )
00390   goto tolua_lerror;
00391  else
00392 #endif
00393  {
00394   {
00395    fawkes::PanTiltInterface::CalibrateMessage* tolua_ret = (fawkes::PanTiltInterface::CalibrateMessage*)  Mtolua_new((fawkes::PanTiltInterface::CalibrateMessage)());
00396     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::CalibrateMessage");
00397     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00398   }
00399  }
00400  return 1;
00401 #ifndef TOLUA_RELEASE
00402  tolua_lerror:
00403  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00404  return 0;
00405 #endif
00406 }
00407 #endif //#ifndef TOLUA_DISABLE
00408 
00409 /* method: delete of class  CalibrateMessage */
00410 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_delete00
00411 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_delete00(lua_State* tolua_S)
00412 {
00413 #ifndef TOLUA_RELEASE
00414  tolua_Error tolua_err;
00415  if (
00416      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::CalibrateMessage",0,&tolua_err) ||
00417      !tolua_isnoobj(tolua_S,2,&tolua_err)
00418  )
00419   goto tolua_lerror;
00420  else
00421 #endif
00422  {
00423   fawkes::PanTiltInterface::CalibrateMessage* self = (fawkes::PanTiltInterface::CalibrateMessage*)  tolua_tousertype(tolua_S,1,0);
00424 #ifndef TOLUA_RELEASE
00425   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00426 #endif
00427   Mtolua_delete(self);
00428  }
00429  return 0;
00430 #ifndef TOLUA_RELEASE
00431  tolua_lerror:
00432  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00433  return 0;
00434 #endif
00435 }
00436 #endif //#ifndef TOLUA_DISABLE
00437 
00438 /* method: new of class  ParkMessage */
00439 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_new00
00440 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_new00(lua_State* tolua_S)
00441 {
00442 #ifndef TOLUA_RELEASE
00443  tolua_Error tolua_err;
00444  if (
00445      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::ParkMessage",0,&tolua_err) ||
00446      !tolua_isnoobj(tolua_S,2,&tolua_err)
00447  )
00448   goto tolua_lerror;
00449  else
00450 #endif
00451  {
00452   {
00453    fawkes::PanTiltInterface::ParkMessage* tolua_ret = (fawkes::PanTiltInterface::ParkMessage*)  Mtolua_new((fawkes::PanTiltInterface::ParkMessage)());
00454     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::ParkMessage");
00455   }
00456  }
00457  return 1;
00458 #ifndef TOLUA_RELEASE
00459  tolua_lerror:
00460  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00461  return 0;
00462 #endif
00463 }
00464 #endif //#ifndef TOLUA_DISABLE
00465 
00466 /* method: new_local of class  ParkMessage */
00467 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_new00_local
00468 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_new00_local(lua_State* tolua_S)
00469 {
00470 #ifndef TOLUA_RELEASE
00471  tolua_Error tolua_err;
00472  if (
00473      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::ParkMessage",0,&tolua_err) ||
00474      !tolua_isnoobj(tolua_S,2,&tolua_err)
00475  )
00476   goto tolua_lerror;
00477  else
00478 #endif
00479  {
00480   {
00481    fawkes::PanTiltInterface::ParkMessage* tolua_ret = (fawkes::PanTiltInterface::ParkMessage*)  Mtolua_new((fawkes::PanTiltInterface::ParkMessage)());
00482     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::ParkMessage");
00483     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00484   }
00485  }
00486  return 1;
00487 #ifndef TOLUA_RELEASE
00488  tolua_lerror:
00489  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00490  return 0;
00491 #endif
00492 }
00493 #endif //#ifndef TOLUA_DISABLE
00494 
00495 /* method: delete of class  ParkMessage */
00496 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_delete00
00497 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_delete00(lua_State* tolua_S)
00498 {
00499 #ifndef TOLUA_RELEASE
00500  tolua_Error tolua_err;
00501  if (
00502      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::ParkMessage",0,&tolua_err) ||
00503      !tolua_isnoobj(tolua_S,2,&tolua_err)
00504  )
00505   goto tolua_lerror;
00506  else
00507 #endif
00508  {
00509   fawkes::PanTiltInterface::ParkMessage* self = (fawkes::PanTiltInterface::ParkMessage*)  tolua_tousertype(tolua_S,1,0);
00510 #ifndef TOLUA_RELEASE
00511   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00512 #endif
00513   Mtolua_delete(self);
00514  }
00515  return 0;
00516 #ifndef TOLUA_RELEASE
00517  tolua_lerror:
00518  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00519  return 0;
00520 #endif
00521 }
00522 #endif //#ifndef TOLUA_DISABLE
00523 
00524 /* method: new of class  GotoMessage */
00525 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new00
00526 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new00(lua_State* tolua_S)
00527 {
00528 #ifndef TOLUA_RELEASE
00529  tolua_Error tolua_err;
00530  if (
00531      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00532      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00533      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00534      !tolua_isnoobj(tolua_S,4,&tolua_err)
00535  )
00536   goto tolua_lerror;
00537  else
00538 #endif
00539  {
00540   float ini_pan = ((float)  tolua_tonumber(tolua_S,2,0));
00541   float ini_tilt = ((float)  tolua_tonumber(tolua_S,3,0));
00542   {
00543    fawkes::PanTiltInterface::GotoMessage* tolua_ret = (fawkes::PanTiltInterface::GotoMessage*)  Mtolua_new((fawkes::PanTiltInterface::GotoMessage)(ini_pan,ini_tilt));
00544     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::GotoMessage");
00545   }
00546  }
00547  return 1;
00548 #ifndef TOLUA_RELEASE
00549  tolua_lerror:
00550  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00551  return 0;
00552 #endif
00553 }
00554 #endif //#ifndef TOLUA_DISABLE
00555 
00556 /* method: new_local of class  GotoMessage */
00557 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new00_local
00558 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new00_local(lua_State* tolua_S)
00559 {
00560 #ifndef TOLUA_RELEASE
00561  tolua_Error tolua_err;
00562  if (
00563      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00564      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00565      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00566      !tolua_isnoobj(tolua_S,4,&tolua_err)
00567  )
00568   goto tolua_lerror;
00569  else
00570 #endif
00571  {
00572   float ini_pan = ((float)  tolua_tonumber(tolua_S,2,0));
00573   float ini_tilt = ((float)  tolua_tonumber(tolua_S,3,0));
00574   {
00575    fawkes::PanTiltInterface::GotoMessage* tolua_ret = (fawkes::PanTiltInterface::GotoMessage*)  Mtolua_new((fawkes::PanTiltInterface::GotoMessage)(ini_pan,ini_tilt));
00576     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::GotoMessage");
00577     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00578   }
00579  }
00580  return 1;
00581 #ifndef TOLUA_RELEASE
00582  tolua_lerror:
00583  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00584  return 0;
00585 #endif
00586 }
00587 #endif //#ifndef TOLUA_DISABLE
00588 
00589 /* method: new of class  GotoMessage */
00590 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new01
00591 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new01(lua_State* tolua_S)
00592 {
00593  tolua_Error tolua_err;
00594  if (
00595      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00596      !tolua_isnoobj(tolua_S,2,&tolua_err)
00597  )
00598   goto tolua_lerror;
00599  else
00600  {
00601   {
00602    fawkes::PanTiltInterface::GotoMessage* tolua_ret = (fawkes::PanTiltInterface::GotoMessage*)  Mtolua_new((fawkes::PanTiltInterface::GotoMessage)());
00603     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::GotoMessage");
00604   }
00605  }
00606  return 1;
00607 tolua_lerror:
00608  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new00(tolua_S);
00609 }
00610 #endif //#ifndef TOLUA_DISABLE
00611 
00612 /* method: new_local of class  GotoMessage */
00613 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new01_local
00614 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new01_local(lua_State* tolua_S)
00615 {
00616  tolua_Error tolua_err;
00617  if (
00618      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00619      !tolua_isnoobj(tolua_S,2,&tolua_err)
00620  )
00621   goto tolua_lerror;
00622  else
00623  {
00624   {
00625    fawkes::PanTiltInterface::GotoMessage* tolua_ret = (fawkes::PanTiltInterface::GotoMessage*)  Mtolua_new((fawkes::PanTiltInterface::GotoMessage)());
00626     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::GotoMessage");
00627     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00628   }
00629  }
00630  return 1;
00631 tolua_lerror:
00632  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new00_local(tolua_S);
00633 }
00634 #endif //#ifndef TOLUA_DISABLE
00635 
00636 /* method: delete of class  GotoMessage */
00637 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_delete00
00638 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_delete00(lua_State* tolua_S)
00639 {
00640 #ifndef TOLUA_RELEASE
00641  tolua_Error tolua_err;
00642  if (
00643      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00644      !tolua_isnoobj(tolua_S,2,&tolua_err)
00645  )
00646   goto tolua_lerror;
00647  else
00648 #endif
00649  {
00650   fawkes::PanTiltInterface::GotoMessage* self = (fawkes::PanTiltInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
00651 #ifndef TOLUA_RELEASE
00652   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00653 #endif
00654   Mtolua_delete(self);
00655  }
00656  return 0;
00657 #ifndef TOLUA_RELEASE
00658  tolua_lerror:
00659  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00660  return 0;
00661 #endif
00662 }
00663 #endif //#ifndef TOLUA_DISABLE
00664 
00665 /* method: pan of class  GotoMessage */
00666 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_pan00
00667 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_pan00(lua_State* tolua_S)
00668 {
00669 #ifndef TOLUA_RELEASE
00670  tolua_Error tolua_err;
00671  if (
00672      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00673      !tolua_isnoobj(tolua_S,2,&tolua_err)
00674  )
00675   goto tolua_lerror;
00676  else
00677 #endif
00678  {
00679   fawkes::PanTiltInterface::GotoMessage* self = (fawkes::PanTiltInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
00680 #ifndef TOLUA_RELEASE
00681   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pan'", NULL);
00682 #endif
00683   {
00684    float tolua_ret = (float)  self->pan();
00685    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00686   }
00687  }
00688  return 1;
00689 #ifndef TOLUA_RELEASE
00690  tolua_lerror:
00691  tolua_error(tolua_S,"#ferror in function 'pan'.",&tolua_err);
00692  return 0;
00693 #endif
00694 }
00695 #endif //#ifndef TOLUA_DISABLE
00696 
00697 /* method: set_pan of class  GotoMessage */
00698 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_set_pan00
00699 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_set_pan00(lua_State* tolua_S)
00700 {
00701 #ifndef TOLUA_RELEASE
00702  tolua_Error tolua_err;
00703  if (
00704      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00705      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00706      !tolua_isnoobj(tolua_S,3,&tolua_err)
00707  )
00708   goto tolua_lerror;
00709  else
00710 #endif
00711  {
00712   fawkes::PanTiltInterface::GotoMessage* self = (fawkes::PanTiltInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
00713   const float new_pan = ((const float)  tolua_tonumber(tolua_S,2,0));
00714 #ifndef TOLUA_RELEASE
00715   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_pan'", NULL);
00716 #endif
00717   {
00718    self->set_pan(new_pan);
00719   }
00720  }
00721  return 0;
00722 #ifndef TOLUA_RELEASE
00723  tolua_lerror:
00724  tolua_error(tolua_S,"#ferror in function 'set_pan'.",&tolua_err);
00725  return 0;
00726 #endif
00727 }
00728 #endif //#ifndef TOLUA_DISABLE
00729 
00730 /* method: maxlenof_pan of class  GotoMessage */
00731 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_maxlenof_pan00
00732 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_maxlenof_pan00(lua_State* tolua_S)
00733 {
00734 #ifndef TOLUA_RELEASE
00735  tolua_Error tolua_err;
00736  if (
00737      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00738      !tolua_isnoobj(tolua_S,2,&tolua_err)
00739  )
00740   goto tolua_lerror;
00741  else
00742 #endif
00743  {
00744   const fawkes::PanTiltInterface::GotoMessage* self = (const fawkes::PanTiltInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
00745 #ifndef TOLUA_RELEASE
00746   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_pan'", NULL);
00747 #endif
00748   {
00749    int tolua_ret = (int)  self->maxlenof_pan();
00750    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00751   }
00752  }
00753  return 1;
00754 #ifndef TOLUA_RELEASE
00755  tolua_lerror:
00756  tolua_error(tolua_S,"#ferror in function 'maxlenof_pan'.",&tolua_err);
00757  return 0;
00758 #endif
00759 }
00760 #endif //#ifndef TOLUA_DISABLE
00761 
00762 /* method: tilt of class  GotoMessage */
00763 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_tilt00
00764 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_tilt00(lua_State* tolua_S)
00765 {
00766 #ifndef TOLUA_RELEASE
00767  tolua_Error tolua_err;
00768  if (
00769      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00770      !tolua_isnoobj(tolua_S,2,&tolua_err)
00771  )
00772   goto tolua_lerror;
00773  else
00774 #endif
00775  {
00776   fawkes::PanTiltInterface::GotoMessage* self = (fawkes::PanTiltInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
00777 #ifndef TOLUA_RELEASE
00778   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tilt'", NULL);
00779 #endif
00780   {
00781    float tolua_ret = (float)  self->tilt();
00782    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00783   }
00784  }
00785  return 1;
00786 #ifndef TOLUA_RELEASE
00787  tolua_lerror:
00788  tolua_error(tolua_S,"#ferror in function 'tilt'.",&tolua_err);
00789  return 0;
00790 #endif
00791 }
00792 #endif //#ifndef TOLUA_DISABLE
00793 
00794 /* method: set_tilt of class  GotoMessage */
00795 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_set_tilt00
00796 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_set_tilt00(lua_State* tolua_S)
00797 {
00798 #ifndef TOLUA_RELEASE
00799  tolua_Error tolua_err;
00800  if (
00801      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00802      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00803      !tolua_isnoobj(tolua_S,3,&tolua_err)
00804  )
00805   goto tolua_lerror;
00806  else
00807 #endif
00808  {
00809   fawkes::PanTiltInterface::GotoMessage* self = (fawkes::PanTiltInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
00810   const float new_tilt = ((const float)  tolua_tonumber(tolua_S,2,0));
00811 #ifndef TOLUA_RELEASE
00812   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_tilt'", NULL);
00813 #endif
00814   {
00815    self->set_tilt(new_tilt);
00816   }
00817  }
00818  return 0;
00819 #ifndef TOLUA_RELEASE
00820  tolua_lerror:
00821  tolua_error(tolua_S,"#ferror in function 'set_tilt'.",&tolua_err);
00822  return 0;
00823 #endif
00824 }
00825 #endif //#ifndef TOLUA_DISABLE
00826 
00827 /* method: maxlenof_tilt of class  GotoMessage */
00828 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_maxlenof_tilt00
00829 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_maxlenof_tilt00(lua_State* tolua_S)
00830 {
00831 #ifndef TOLUA_RELEASE
00832  tolua_Error tolua_err;
00833  if (
00834      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::GotoMessage",0,&tolua_err) ||
00835      !tolua_isnoobj(tolua_S,2,&tolua_err)
00836  )
00837   goto tolua_lerror;
00838  else
00839 #endif
00840  {
00841   const fawkes::PanTiltInterface::GotoMessage* self = (const fawkes::PanTiltInterface::GotoMessage*)  tolua_tousertype(tolua_S,1,0);
00842 #ifndef TOLUA_RELEASE
00843   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_tilt'", NULL);
00844 #endif
00845   {
00846    int tolua_ret = (int)  self->maxlenof_tilt();
00847    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00848   }
00849  }
00850  return 1;
00851 #ifndef TOLUA_RELEASE
00852  tolua_lerror:
00853  tolua_error(tolua_S,"#ferror in function 'maxlenof_tilt'.",&tolua_err);
00854  return 0;
00855 #endif
00856 }
00857 #endif //#ifndef TOLUA_DISABLE
00858 
00859 /* method: new of class  TimedGotoMessage */
00860 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new00
00861 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new00(lua_State* tolua_S)
00862 {
00863 #ifndef TOLUA_RELEASE
00864  tolua_Error tolua_err;
00865  if (
00866      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
00867      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00868      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00869      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00870      !tolua_isnoobj(tolua_S,5,&tolua_err)
00871  )
00872   goto tolua_lerror;
00873  else
00874 #endif
00875  {
00876   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,2,0));
00877   float ini_pan = ((float)  tolua_tonumber(tolua_S,3,0));
00878   float ini_tilt = ((float)  tolua_tonumber(tolua_S,4,0));
00879   {
00880    fawkes::PanTiltInterface::TimedGotoMessage* tolua_ret = (fawkes::PanTiltInterface::TimedGotoMessage*)  Mtolua_new((fawkes::PanTiltInterface::TimedGotoMessage)(ini_time_sec,ini_pan,ini_tilt));
00881     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::TimedGotoMessage");
00882   }
00883  }
00884  return 1;
00885 #ifndef TOLUA_RELEASE
00886  tolua_lerror:
00887  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00888  return 0;
00889 #endif
00890 }
00891 #endif //#ifndef TOLUA_DISABLE
00892 
00893 /* method: new_local of class  TimedGotoMessage */
00894 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new00_local
00895 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new00_local(lua_State* tolua_S)
00896 {
00897 #ifndef TOLUA_RELEASE
00898  tolua_Error tolua_err;
00899  if (
00900      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
00901      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00902      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00903      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00904      !tolua_isnoobj(tolua_S,5,&tolua_err)
00905  )
00906   goto tolua_lerror;
00907  else
00908 #endif
00909  {
00910   float ini_time_sec = ((float)  tolua_tonumber(tolua_S,2,0));
00911   float ini_pan = ((float)  tolua_tonumber(tolua_S,3,0));
00912   float ini_tilt = ((float)  tolua_tonumber(tolua_S,4,0));
00913   {
00914    fawkes::PanTiltInterface::TimedGotoMessage* tolua_ret = (fawkes::PanTiltInterface::TimedGotoMessage*)  Mtolua_new((fawkes::PanTiltInterface::TimedGotoMessage)(ini_time_sec,ini_pan,ini_tilt));
00915     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::TimedGotoMessage");
00916     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00917   }
00918  }
00919  return 1;
00920 #ifndef TOLUA_RELEASE
00921  tolua_lerror:
00922  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00923  return 0;
00924 #endif
00925 }
00926 #endif //#ifndef TOLUA_DISABLE
00927 
00928 /* method: new of class  TimedGotoMessage */
00929 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new01
00930 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new01(lua_State* tolua_S)
00931 {
00932  tolua_Error tolua_err;
00933  if (
00934      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
00935      !tolua_isnoobj(tolua_S,2,&tolua_err)
00936  )
00937   goto tolua_lerror;
00938  else
00939  {
00940   {
00941    fawkes::PanTiltInterface::TimedGotoMessage* tolua_ret = (fawkes::PanTiltInterface::TimedGotoMessage*)  Mtolua_new((fawkes::PanTiltInterface::TimedGotoMessage)());
00942     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::TimedGotoMessage");
00943   }
00944  }
00945  return 1;
00946 tolua_lerror:
00947  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new00(tolua_S);
00948 }
00949 #endif //#ifndef TOLUA_DISABLE
00950 
00951 /* method: new_local of class  TimedGotoMessage */
00952 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new01_local
00953 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new01_local(lua_State* tolua_S)
00954 {
00955  tolua_Error tolua_err;
00956  if (
00957      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
00958      !tolua_isnoobj(tolua_S,2,&tolua_err)
00959  )
00960   goto tolua_lerror;
00961  else
00962  {
00963   {
00964    fawkes::PanTiltInterface::TimedGotoMessage* tolua_ret = (fawkes::PanTiltInterface::TimedGotoMessage*)  Mtolua_new((fawkes::PanTiltInterface::TimedGotoMessage)());
00965     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::TimedGotoMessage");
00966     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00967   }
00968  }
00969  return 1;
00970 tolua_lerror:
00971  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new00_local(tolua_S);
00972 }
00973 #endif //#ifndef TOLUA_DISABLE
00974 
00975 /* method: delete of class  TimedGotoMessage */
00976 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_delete00
00977 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_delete00(lua_State* tolua_S)
00978 {
00979 #ifndef TOLUA_RELEASE
00980  tolua_Error tolua_err;
00981  if (
00982      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
00983      !tolua_isnoobj(tolua_S,2,&tolua_err)
00984  )
00985   goto tolua_lerror;
00986  else
00987 #endif
00988  {
00989   fawkes::PanTiltInterface::TimedGotoMessage* self = (fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
00990 #ifndef TOLUA_RELEASE
00991   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00992 #endif
00993   Mtolua_delete(self);
00994  }
00995  return 0;
00996 #ifndef TOLUA_RELEASE
00997  tolua_lerror:
00998  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00999  return 0;
01000 #endif
01001 }
01002 #endif //#ifndef TOLUA_DISABLE
01003 
01004 /* method: time_sec of class  TimedGotoMessage */
01005 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_time_sec00
01006 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_time_sec00(lua_State* tolua_S)
01007 {
01008 #ifndef TOLUA_RELEASE
01009  tolua_Error tolua_err;
01010  if (
01011      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
01012      !tolua_isnoobj(tolua_S,2,&tolua_err)
01013  )
01014   goto tolua_lerror;
01015  else
01016 #endif
01017  {
01018   fawkes::PanTiltInterface::TimedGotoMessage* self = (fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01019 #ifndef TOLUA_RELEASE
01020   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'time_sec'", NULL);
01021 #endif
01022   {
01023    float tolua_ret = (float)  self->time_sec();
01024    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01025   }
01026  }
01027  return 1;
01028 #ifndef TOLUA_RELEASE
01029  tolua_lerror:
01030  tolua_error(tolua_S,"#ferror in function 'time_sec'.",&tolua_err);
01031  return 0;
01032 #endif
01033 }
01034 #endif //#ifndef TOLUA_DISABLE
01035 
01036 /* method: set_time_sec of class  TimedGotoMessage */
01037 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_set_time_sec00
01038 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_set_time_sec00(lua_State* tolua_S)
01039 {
01040 #ifndef TOLUA_RELEASE
01041  tolua_Error tolua_err;
01042  if (
01043      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
01044      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01045      !tolua_isnoobj(tolua_S,3,&tolua_err)
01046  )
01047   goto tolua_lerror;
01048  else
01049 #endif
01050  {
01051   fawkes::PanTiltInterface::TimedGotoMessage* self = (fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01052   const float new_time_sec = ((const float)  tolua_tonumber(tolua_S,2,0));
01053 #ifndef TOLUA_RELEASE
01054   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_time_sec'", NULL);
01055 #endif
01056   {
01057    self->set_time_sec(new_time_sec);
01058   }
01059  }
01060  return 0;
01061 #ifndef TOLUA_RELEASE
01062  tolua_lerror:
01063  tolua_error(tolua_S,"#ferror in function 'set_time_sec'.",&tolua_err);
01064  return 0;
01065 #endif
01066 }
01067 #endif //#ifndef TOLUA_DISABLE
01068 
01069 /* method: maxlenof_time_sec of class  TimedGotoMessage */
01070 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_maxlenof_time_sec00
01071 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_maxlenof_time_sec00(lua_State* tolua_S)
01072 {
01073 #ifndef TOLUA_RELEASE
01074  tolua_Error tolua_err;
01075  if (
01076      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
01077      !tolua_isnoobj(tolua_S,2,&tolua_err)
01078  )
01079   goto tolua_lerror;
01080  else
01081 #endif
01082  {
01083   const fawkes::PanTiltInterface::TimedGotoMessage* self = (const fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01084 #ifndef TOLUA_RELEASE
01085   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_time_sec'", NULL);
01086 #endif
01087   {
01088    int tolua_ret = (int)  self->maxlenof_time_sec();
01089    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01090   }
01091  }
01092  return 1;
01093 #ifndef TOLUA_RELEASE
01094  tolua_lerror:
01095  tolua_error(tolua_S,"#ferror in function 'maxlenof_time_sec'.",&tolua_err);
01096  return 0;
01097 #endif
01098 }
01099 #endif //#ifndef TOLUA_DISABLE
01100 
01101 /* method: pan of class  TimedGotoMessage */
01102 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_pan00
01103 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_pan00(lua_State* tolua_S)
01104 {
01105 #ifndef TOLUA_RELEASE
01106  tolua_Error tolua_err;
01107  if (
01108      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
01109      !tolua_isnoobj(tolua_S,2,&tolua_err)
01110  )
01111   goto tolua_lerror;
01112  else
01113 #endif
01114  {
01115   fawkes::PanTiltInterface::TimedGotoMessage* self = (fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01116 #ifndef TOLUA_RELEASE
01117   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pan'", NULL);
01118 #endif
01119   {
01120    float tolua_ret = (float)  self->pan();
01121    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01122   }
01123  }
01124  return 1;
01125 #ifndef TOLUA_RELEASE
01126  tolua_lerror:
01127  tolua_error(tolua_S,"#ferror in function 'pan'.",&tolua_err);
01128  return 0;
01129 #endif
01130 }
01131 #endif //#ifndef TOLUA_DISABLE
01132 
01133 /* method: set_pan of class  TimedGotoMessage */
01134 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_set_pan00
01135 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_set_pan00(lua_State* tolua_S)
01136 {
01137 #ifndef TOLUA_RELEASE
01138  tolua_Error tolua_err;
01139  if (
01140      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
01141      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01142      !tolua_isnoobj(tolua_S,3,&tolua_err)
01143  )
01144   goto tolua_lerror;
01145  else
01146 #endif
01147  {
01148   fawkes::PanTiltInterface::TimedGotoMessage* self = (fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01149   const float new_pan = ((const float)  tolua_tonumber(tolua_S,2,0));
01150 #ifndef TOLUA_RELEASE
01151   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_pan'", NULL);
01152 #endif
01153   {
01154    self->set_pan(new_pan);
01155   }
01156  }
01157  return 0;
01158 #ifndef TOLUA_RELEASE
01159  tolua_lerror:
01160  tolua_error(tolua_S,"#ferror in function 'set_pan'.",&tolua_err);
01161  return 0;
01162 #endif
01163 }
01164 #endif //#ifndef TOLUA_DISABLE
01165 
01166 /* method: maxlenof_pan of class  TimedGotoMessage */
01167 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_maxlenof_pan00
01168 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_maxlenof_pan00(lua_State* tolua_S)
01169 {
01170 #ifndef TOLUA_RELEASE
01171  tolua_Error tolua_err;
01172  if (
01173      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
01174      !tolua_isnoobj(tolua_S,2,&tolua_err)
01175  )
01176   goto tolua_lerror;
01177  else
01178 #endif
01179  {
01180   const fawkes::PanTiltInterface::TimedGotoMessage* self = (const fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01181 #ifndef TOLUA_RELEASE
01182   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_pan'", NULL);
01183 #endif
01184   {
01185    int tolua_ret = (int)  self->maxlenof_pan();
01186    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01187   }
01188  }
01189  return 1;
01190 #ifndef TOLUA_RELEASE
01191  tolua_lerror:
01192  tolua_error(tolua_S,"#ferror in function 'maxlenof_pan'.",&tolua_err);
01193  return 0;
01194 #endif
01195 }
01196 #endif //#ifndef TOLUA_DISABLE
01197 
01198 /* method: tilt of class  TimedGotoMessage */
01199 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_tilt00
01200 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_tilt00(lua_State* tolua_S)
01201 {
01202 #ifndef TOLUA_RELEASE
01203  tolua_Error tolua_err;
01204  if (
01205      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
01206      !tolua_isnoobj(tolua_S,2,&tolua_err)
01207  )
01208   goto tolua_lerror;
01209  else
01210 #endif
01211  {
01212   fawkes::PanTiltInterface::TimedGotoMessage* self = (fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01213 #ifndef TOLUA_RELEASE
01214   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tilt'", NULL);
01215 #endif
01216   {
01217    float tolua_ret = (float)  self->tilt();
01218    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01219   }
01220  }
01221  return 1;
01222 #ifndef TOLUA_RELEASE
01223  tolua_lerror:
01224  tolua_error(tolua_S,"#ferror in function 'tilt'.",&tolua_err);
01225  return 0;
01226 #endif
01227 }
01228 #endif //#ifndef TOLUA_DISABLE
01229 
01230 /* method: set_tilt of class  TimedGotoMessage */
01231 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_set_tilt00
01232 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_set_tilt00(lua_State* tolua_S)
01233 {
01234 #ifndef TOLUA_RELEASE
01235  tolua_Error tolua_err;
01236  if (
01237      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
01238      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01239      !tolua_isnoobj(tolua_S,3,&tolua_err)
01240  )
01241   goto tolua_lerror;
01242  else
01243 #endif
01244  {
01245   fawkes::PanTiltInterface::TimedGotoMessage* self = (fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01246   const float new_tilt = ((const float)  tolua_tonumber(tolua_S,2,0));
01247 #ifndef TOLUA_RELEASE
01248   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_tilt'", NULL);
01249 #endif
01250   {
01251    self->set_tilt(new_tilt);
01252   }
01253  }
01254  return 0;
01255 #ifndef TOLUA_RELEASE
01256  tolua_lerror:
01257  tolua_error(tolua_S,"#ferror in function 'set_tilt'.",&tolua_err);
01258  return 0;
01259 #endif
01260 }
01261 #endif //#ifndef TOLUA_DISABLE
01262 
01263 /* method: maxlenof_tilt of class  TimedGotoMessage */
01264 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_maxlenof_tilt00
01265 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_maxlenof_tilt00(lua_State* tolua_S)
01266 {
01267 #ifndef TOLUA_RELEASE
01268  tolua_Error tolua_err;
01269  if (
01270      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::TimedGotoMessage",0,&tolua_err) ||
01271      !tolua_isnoobj(tolua_S,2,&tolua_err)
01272  )
01273   goto tolua_lerror;
01274  else
01275 #endif
01276  {
01277   const fawkes::PanTiltInterface::TimedGotoMessage* self = (const fawkes::PanTiltInterface::TimedGotoMessage*)  tolua_tousertype(tolua_S,1,0);
01278 #ifndef TOLUA_RELEASE
01279   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_tilt'", NULL);
01280 #endif
01281   {
01282    int tolua_ret = (int)  self->maxlenof_tilt();
01283    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01284   }
01285  }
01286  return 1;
01287 #ifndef TOLUA_RELEASE
01288  tolua_lerror:
01289  tolua_error(tolua_S,"#ferror in function 'maxlenof_tilt'.",&tolua_err);
01290  return 0;
01291 #endif
01292 }
01293 #endif //#ifndef TOLUA_DISABLE
01294 
01295 /* method: new of class  SetEnabledMessage */
01296 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new00
01297 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new00(lua_State* tolua_S)
01298 {
01299 #ifndef TOLUA_RELEASE
01300  tolua_Error tolua_err;
01301  if (
01302      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetEnabledMessage",0,&tolua_err) ||
01303      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01304      !tolua_isnoobj(tolua_S,3,&tolua_err)
01305  )
01306   goto tolua_lerror;
01307  else
01308 #endif
01309  {
01310   bool ini_enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
01311   {
01312    fawkes::PanTiltInterface::SetEnabledMessage* tolua_ret = (fawkes::PanTiltInterface::SetEnabledMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetEnabledMessage)(ini_enabled));
01313     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetEnabledMessage");
01314   }
01315  }
01316  return 1;
01317 #ifndef TOLUA_RELEASE
01318  tolua_lerror:
01319  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01320  return 0;
01321 #endif
01322 }
01323 #endif //#ifndef TOLUA_DISABLE
01324 
01325 /* method: new_local of class  SetEnabledMessage */
01326 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new00_local
01327 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new00_local(lua_State* tolua_S)
01328 {
01329 #ifndef TOLUA_RELEASE
01330  tolua_Error tolua_err;
01331  if (
01332      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetEnabledMessage",0,&tolua_err) ||
01333      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01334      !tolua_isnoobj(tolua_S,3,&tolua_err)
01335  )
01336   goto tolua_lerror;
01337  else
01338 #endif
01339  {
01340   bool ini_enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
01341   {
01342    fawkes::PanTiltInterface::SetEnabledMessage* tolua_ret = (fawkes::PanTiltInterface::SetEnabledMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetEnabledMessage)(ini_enabled));
01343     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetEnabledMessage");
01344     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01345   }
01346  }
01347  return 1;
01348 #ifndef TOLUA_RELEASE
01349  tolua_lerror:
01350  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01351  return 0;
01352 #endif
01353 }
01354 #endif //#ifndef TOLUA_DISABLE
01355 
01356 /* method: new of class  SetEnabledMessage */
01357 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new01
01358 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new01(lua_State* tolua_S)
01359 {
01360  tolua_Error tolua_err;
01361  if (
01362      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetEnabledMessage",0,&tolua_err) ||
01363      !tolua_isnoobj(tolua_S,2,&tolua_err)
01364  )
01365   goto tolua_lerror;
01366  else
01367  {
01368   {
01369    fawkes::PanTiltInterface::SetEnabledMessage* tolua_ret = (fawkes::PanTiltInterface::SetEnabledMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetEnabledMessage)());
01370     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetEnabledMessage");
01371   }
01372  }
01373  return 1;
01374 tolua_lerror:
01375  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new00(tolua_S);
01376 }
01377 #endif //#ifndef TOLUA_DISABLE
01378 
01379 /* method: new_local of class  SetEnabledMessage */
01380 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new01_local
01381 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new01_local(lua_State* tolua_S)
01382 {
01383  tolua_Error tolua_err;
01384  if (
01385      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetEnabledMessage",0,&tolua_err) ||
01386      !tolua_isnoobj(tolua_S,2,&tolua_err)
01387  )
01388   goto tolua_lerror;
01389  else
01390  {
01391   {
01392    fawkes::PanTiltInterface::SetEnabledMessage* tolua_ret = (fawkes::PanTiltInterface::SetEnabledMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetEnabledMessage)());
01393     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetEnabledMessage");
01394     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01395   }
01396  }
01397  return 1;
01398 tolua_lerror:
01399  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new00_local(tolua_S);
01400 }
01401 #endif //#ifndef TOLUA_DISABLE
01402 
01403 /* method: delete of class  SetEnabledMessage */
01404 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_delete00
01405 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_delete00(lua_State* tolua_S)
01406 {
01407 #ifndef TOLUA_RELEASE
01408  tolua_Error tolua_err;
01409  if (
01410      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetEnabledMessage",0,&tolua_err) ||
01411      !tolua_isnoobj(tolua_S,2,&tolua_err)
01412  )
01413   goto tolua_lerror;
01414  else
01415 #endif
01416  {
01417   fawkes::PanTiltInterface::SetEnabledMessage* self = (fawkes::PanTiltInterface::SetEnabledMessage*)  tolua_tousertype(tolua_S,1,0);
01418 #ifndef TOLUA_RELEASE
01419   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01420 #endif
01421   Mtolua_delete(self);
01422  }
01423  return 0;
01424 #ifndef TOLUA_RELEASE
01425  tolua_lerror:
01426  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01427  return 0;
01428 #endif
01429 }
01430 #endif //#ifndef TOLUA_DISABLE
01431 
01432 /* method: is_enabled of class  SetEnabledMessage */
01433 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_is_enabled00
01434 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_is_enabled00(lua_State* tolua_S)
01435 {
01436 #ifndef TOLUA_RELEASE
01437  tolua_Error tolua_err;
01438  if (
01439      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetEnabledMessage",0,&tolua_err) ||
01440      !tolua_isnoobj(tolua_S,2,&tolua_err)
01441  )
01442   goto tolua_lerror;
01443  else
01444 #endif
01445  {
01446   fawkes::PanTiltInterface::SetEnabledMessage* self = (fawkes::PanTiltInterface::SetEnabledMessage*)  tolua_tousertype(tolua_S,1,0);
01447 #ifndef TOLUA_RELEASE
01448   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'", NULL);
01449 #endif
01450   {
01451    bool tolua_ret = (bool)  self->is_enabled();
01452    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01453   }
01454  }
01455  return 1;
01456 #ifndef TOLUA_RELEASE
01457  tolua_lerror:
01458  tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err);
01459  return 0;
01460 #endif
01461 }
01462 #endif //#ifndef TOLUA_DISABLE
01463 
01464 /* method: set_enabled of class  SetEnabledMessage */
01465 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_set_enabled00
01466 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_set_enabled00(lua_State* tolua_S)
01467 {
01468 #ifndef TOLUA_RELEASE
01469  tolua_Error tolua_err;
01470  if (
01471      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetEnabledMessage",0,&tolua_err) ||
01472      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01473      !tolua_isnoobj(tolua_S,3,&tolua_err)
01474  )
01475   goto tolua_lerror;
01476  else
01477 #endif
01478  {
01479   fawkes::PanTiltInterface::SetEnabledMessage* self = (fawkes::PanTiltInterface::SetEnabledMessage*)  tolua_tousertype(tolua_S,1,0);
01480   const bool new_enabled = ((const bool)  tolua_toboolean(tolua_S,2,0));
01481 #ifndef TOLUA_RELEASE
01482   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'", NULL);
01483 #endif
01484   {
01485    self->set_enabled(new_enabled);
01486   }
01487  }
01488  return 0;
01489 #ifndef TOLUA_RELEASE
01490  tolua_lerror:
01491  tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err);
01492  return 0;
01493 #endif
01494 }
01495 #endif //#ifndef TOLUA_DISABLE
01496 
01497 /* method: maxlenof_enabled of class  SetEnabledMessage */
01498 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_maxlenof_enabled00
01499 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_maxlenof_enabled00(lua_State* tolua_S)
01500 {
01501 #ifndef TOLUA_RELEASE
01502  tolua_Error tolua_err;
01503  if (
01504      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::SetEnabledMessage",0,&tolua_err) ||
01505      !tolua_isnoobj(tolua_S,2,&tolua_err)
01506  )
01507   goto tolua_lerror;
01508  else
01509 #endif
01510  {
01511   const fawkes::PanTiltInterface::SetEnabledMessage* self = (const fawkes::PanTiltInterface::SetEnabledMessage*)  tolua_tousertype(tolua_S,1,0);
01512 #ifndef TOLUA_RELEASE
01513   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'", NULL);
01514 #endif
01515   {
01516    int tolua_ret = (int)  self->maxlenof_enabled();
01517    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01518   }
01519  }
01520  return 1;
01521 #ifndef TOLUA_RELEASE
01522  tolua_lerror:
01523  tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err);
01524  return 0;
01525 #endif
01526 }
01527 #endif //#ifndef TOLUA_DISABLE
01528 
01529 /* method: new of class  SetVelocityMessage */
01530 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new00
01531 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new00(lua_State* tolua_S)
01532 {
01533 #ifndef TOLUA_RELEASE
01534  tolua_Error tolua_err;
01535  if (
01536      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01537      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01538      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01539      !tolua_isnoobj(tolua_S,4,&tolua_err)
01540  )
01541   goto tolua_lerror;
01542  else
01543 #endif
01544  {
01545   float ini_pan_velocity = ((float)  tolua_tonumber(tolua_S,2,0));
01546   float ini_tilt_velocity = ((float)  tolua_tonumber(tolua_S,3,0));
01547   {
01548    fawkes::PanTiltInterface::SetVelocityMessage* tolua_ret = (fawkes::PanTiltInterface::SetVelocityMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetVelocityMessage)(ini_pan_velocity,ini_tilt_velocity));
01549     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetVelocityMessage");
01550   }
01551  }
01552  return 1;
01553 #ifndef TOLUA_RELEASE
01554  tolua_lerror:
01555  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01556  return 0;
01557 #endif
01558 }
01559 #endif //#ifndef TOLUA_DISABLE
01560 
01561 /* method: new_local of class  SetVelocityMessage */
01562 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new00_local
01563 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new00_local(lua_State* tolua_S)
01564 {
01565 #ifndef TOLUA_RELEASE
01566  tolua_Error tolua_err;
01567  if (
01568      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01569      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01570      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01571      !tolua_isnoobj(tolua_S,4,&tolua_err)
01572  )
01573   goto tolua_lerror;
01574  else
01575 #endif
01576  {
01577   float ini_pan_velocity = ((float)  tolua_tonumber(tolua_S,2,0));
01578   float ini_tilt_velocity = ((float)  tolua_tonumber(tolua_S,3,0));
01579   {
01580    fawkes::PanTiltInterface::SetVelocityMessage* tolua_ret = (fawkes::PanTiltInterface::SetVelocityMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetVelocityMessage)(ini_pan_velocity,ini_tilt_velocity));
01581     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetVelocityMessage");
01582     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01583   }
01584  }
01585  return 1;
01586 #ifndef TOLUA_RELEASE
01587  tolua_lerror:
01588  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01589  return 0;
01590 #endif
01591 }
01592 #endif //#ifndef TOLUA_DISABLE
01593 
01594 /* method: new of class  SetVelocityMessage */
01595 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new01
01596 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new01(lua_State* tolua_S)
01597 {
01598  tolua_Error tolua_err;
01599  if (
01600      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01601      !tolua_isnoobj(tolua_S,2,&tolua_err)
01602  )
01603   goto tolua_lerror;
01604  else
01605  {
01606   {
01607    fawkes::PanTiltInterface::SetVelocityMessage* tolua_ret = (fawkes::PanTiltInterface::SetVelocityMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetVelocityMessage)());
01608     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetVelocityMessage");
01609   }
01610  }
01611  return 1;
01612 tolua_lerror:
01613  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new00(tolua_S);
01614 }
01615 #endif //#ifndef TOLUA_DISABLE
01616 
01617 /* method: new_local of class  SetVelocityMessage */
01618 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new01_local
01619 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new01_local(lua_State* tolua_S)
01620 {
01621  tolua_Error tolua_err;
01622  if (
01623      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01624      !tolua_isnoobj(tolua_S,2,&tolua_err)
01625  )
01626   goto tolua_lerror;
01627  else
01628  {
01629   {
01630    fawkes::PanTiltInterface::SetVelocityMessage* tolua_ret = (fawkes::PanTiltInterface::SetVelocityMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetVelocityMessage)());
01631     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetVelocityMessage");
01632     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01633   }
01634  }
01635  return 1;
01636 tolua_lerror:
01637  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new00_local(tolua_S);
01638 }
01639 #endif //#ifndef TOLUA_DISABLE
01640 
01641 /* method: delete of class  SetVelocityMessage */
01642 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_delete00
01643 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_delete00(lua_State* tolua_S)
01644 {
01645 #ifndef TOLUA_RELEASE
01646  tolua_Error tolua_err;
01647  if (
01648      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01649      !tolua_isnoobj(tolua_S,2,&tolua_err)
01650  )
01651   goto tolua_lerror;
01652  else
01653 #endif
01654  {
01655   fawkes::PanTiltInterface::SetVelocityMessage* self = (fawkes::PanTiltInterface::SetVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01656 #ifndef TOLUA_RELEASE
01657   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01658 #endif
01659   Mtolua_delete(self);
01660  }
01661  return 0;
01662 #ifndef TOLUA_RELEASE
01663  tolua_lerror:
01664  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01665  return 0;
01666 #endif
01667 }
01668 #endif //#ifndef TOLUA_DISABLE
01669 
01670 /* method: pan_velocity of class  SetVelocityMessage */
01671 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_pan_velocity00
01672 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_pan_velocity00(lua_State* tolua_S)
01673 {
01674 #ifndef TOLUA_RELEASE
01675  tolua_Error tolua_err;
01676  if (
01677      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01678      !tolua_isnoobj(tolua_S,2,&tolua_err)
01679  )
01680   goto tolua_lerror;
01681  else
01682 #endif
01683  {
01684   fawkes::PanTiltInterface::SetVelocityMessage* self = (fawkes::PanTiltInterface::SetVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01685 #ifndef TOLUA_RELEASE
01686   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pan_velocity'", NULL);
01687 #endif
01688   {
01689    float tolua_ret = (float)  self->pan_velocity();
01690    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01691   }
01692  }
01693  return 1;
01694 #ifndef TOLUA_RELEASE
01695  tolua_lerror:
01696  tolua_error(tolua_S,"#ferror in function 'pan_velocity'.",&tolua_err);
01697  return 0;
01698 #endif
01699 }
01700 #endif //#ifndef TOLUA_DISABLE
01701 
01702 /* method: set_pan_velocity of class  SetVelocityMessage */
01703 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_set_pan_velocity00
01704 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_set_pan_velocity00(lua_State* tolua_S)
01705 {
01706 #ifndef TOLUA_RELEASE
01707  tolua_Error tolua_err;
01708  if (
01709      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01710      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01711      !tolua_isnoobj(tolua_S,3,&tolua_err)
01712  )
01713   goto tolua_lerror;
01714  else
01715 #endif
01716  {
01717   fawkes::PanTiltInterface::SetVelocityMessage* self = (fawkes::PanTiltInterface::SetVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01718   const float new_pan_velocity = ((const float)  tolua_tonumber(tolua_S,2,0));
01719 #ifndef TOLUA_RELEASE
01720   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_pan_velocity'", NULL);
01721 #endif
01722   {
01723    self->set_pan_velocity(new_pan_velocity);
01724   }
01725  }
01726  return 0;
01727 #ifndef TOLUA_RELEASE
01728  tolua_lerror:
01729  tolua_error(tolua_S,"#ferror in function 'set_pan_velocity'.",&tolua_err);
01730  return 0;
01731 #endif
01732 }
01733 #endif //#ifndef TOLUA_DISABLE
01734 
01735 /* method: maxlenof_pan_velocity of class  SetVelocityMessage */
01736 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_maxlenof_pan_velocity00
01737 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_maxlenof_pan_velocity00(lua_State* tolua_S)
01738 {
01739 #ifndef TOLUA_RELEASE
01740  tolua_Error tolua_err;
01741  if (
01742      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01743      !tolua_isnoobj(tolua_S,2,&tolua_err)
01744  )
01745   goto tolua_lerror;
01746  else
01747 #endif
01748  {
01749   const fawkes::PanTiltInterface::SetVelocityMessage* self = (const fawkes::PanTiltInterface::SetVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01750 #ifndef TOLUA_RELEASE
01751   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_pan_velocity'", NULL);
01752 #endif
01753   {
01754    int tolua_ret = (int)  self->maxlenof_pan_velocity();
01755    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01756   }
01757  }
01758  return 1;
01759 #ifndef TOLUA_RELEASE
01760  tolua_lerror:
01761  tolua_error(tolua_S,"#ferror in function 'maxlenof_pan_velocity'.",&tolua_err);
01762  return 0;
01763 #endif
01764 }
01765 #endif //#ifndef TOLUA_DISABLE
01766 
01767 /* method: tilt_velocity of class  SetVelocityMessage */
01768 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_tilt_velocity00
01769 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_tilt_velocity00(lua_State* tolua_S)
01770 {
01771 #ifndef TOLUA_RELEASE
01772  tolua_Error tolua_err;
01773  if (
01774      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01775      !tolua_isnoobj(tolua_S,2,&tolua_err)
01776  )
01777   goto tolua_lerror;
01778  else
01779 #endif
01780  {
01781   fawkes::PanTiltInterface::SetVelocityMessage* self = (fawkes::PanTiltInterface::SetVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01782 #ifndef TOLUA_RELEASE
01783   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tilt_velocity'", NULL);
01784 #endif
01785   {
01786    float tolua_ret = (float)  self->tilt_velocity();
01787    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01788   }
01789  }
01790  return 1;
01791 #ifndef TOLUA_RELEASE
01792  tolua_lerror:
01793  tolua_error(tolua_S,"#ferror in function 'tilt_velocity'.",&tolua_err);
01794  return 0;
01795 #endif
01796 }
01797 #endif //#ifndef TOLUA_DISABLE
01798 
01799 /* method: set_tilt_velocity of class  SetVelocityMessage */
01800 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_set_tilt_velocity00
01801 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_set_tilt_velocity00(lua_State* tolua_S)
01802 {
01803 #ifndef TOLUA_RELEASE
01804  tolua_Error tolua_err;
01805  if (
01806      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01807      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01808      !tolua_isnoobj(tolua_S,3,&tolua_err)
01809  )
01810   goto tolua_lerror;
01811  else
01812 #endif
01813  {
01814   fawkes::PanTiltInterface::SetVelocityMessage* self = (fawkes::PanTiltInterface::SetVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01815   const float new_tilt_velocity = ((const float)  tolua_tonumber(tolua_S,2,0));
01816 #ifndef TOLUA_RELEASE
01817   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_tilt_velocity'", NULL);
01818 #endif
01819   {
01820    self->set_tilt_velocity(new_tilt_velocity);
01821   }
01822  }
01823  return 0;
01824 #ifndef TOLUA_RELEASE
01825  tolua_lerror:
01826  tolua_error(tolua_S,"#ferror in function 'set_tilt_velocity'.",&tolua_err);
01827  return 0;
01828 #endif
01829 }
01830 #endif //#ifndef TOLUA_DISABLE
01831 
01832 /* method: maxlenof_tilt_velocity of class  SetVelocityMessage */
01833 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_maxlenof_tilt_velocity00
01834 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_maxlenof_tilt_velocity00(lua_State* tolua_S)
01835 {
01836 #ifndef TOLUA_RELEASE
01837  tolua_Error tolua_err;
01838  if (
01839      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::SetVelocityMessage",0,&tolua_err) ||
01840      !tolua_isnoobj(tolua_S,2,&tolua_err)
01841  )
01842   goto tolua_lerror;
01843  else
01844 #endif
01845  {
01846   const fawkes::PanTiltInterface::SetVelocityMessage* self = (const fawkes::PanTiltInterface::SetVelocityMessage*)  tolua_tousertype(tolua_S,1,0);
01847 #ifndef TOLUA_RELEASE
01848   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_tilt_velocity'", NULL);
01849 #endif
01850   {
01851    int tolua_ret = (int)  self->maxlenof_tilt_velocity();
01852    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01853   }
01854  }
01855  return 1;
01856 #ifndef TOLUA_RELEASE
01857  tolua_lerror:
01858  tolua_error(tolua_S,"#ferror in function 'maxlenof_tilt_velocity'.",&tolua_err);
01859  return 0;
01860 #endif
01861 }
01862 #endif //#ifndef TOLUA_DISABLE
01863 
01864 /* method: new of class  SetMarginMessage */
01865 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new00
01866 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new00(lua_State* tolua_S)
01867 {
01868 #ifndef TOLUA_RELEASE
01869  tolua_Error tolua_err;
01870  if (
01871      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
01872      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01873      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01874      !tolua_isnoobj(tolua_S,4,&tolua_err)
01875  )
01876   goto tolua_lerror;
01877  else
01878 #endif
01879  {
01880   float ini_pan_margin = ((float)  tolua_tonumber(tolua_S,2,0));
01881   float ini_tilt_margin = ((float)  tolua_tonumber(tolua_S,3,0));
01882   {
01883    fawkes::PanTiltInterface::SetMarginMessage* tolua_ret = (fawkes::PanTiltInterface::SetMarginMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetMarginMessage)(ini_pan_margin,ini_tilt_margin));
01884     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetMarginMessage");
01885   }
01886  }
01887  return 1;
01888 #ifndef TOLUA_RELEASE
01889  tolua_lerror:
01890  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01891  return 0;
01892 #endif
01893 }
01894 #endif //#ifndef TOLUA_DISABLE
01895 
01896 /* method: new_local of class  SetMarginMessage */
01897 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new00_local
01898 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new00_local(lua_State* tolua_S)
01899 {
01900 #ifndef TOLUA_RELEASE
01901  tolua_Error tolua_err;
01902  if (
01903      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
01904      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01905      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01906      !tolua_isnoobj(tolua_S,4,&tolua_err)
01907  )
01908   goto tolua_lerror;
01909  else
01910 #endif
01911  {
01912   float ini_pan_margin = ((float)  tolua_tonumber(tolua_S,2,0));
01913   float ini_tilt_margin = ((float)  tolua_tonumber(tolua_S,3,0));
01914   {
01915    fawkes::PanTiltInterface::SetMarginMessage* tolua_ret = (fawkes::PanTiltInterface::SetMarginMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetMarginMessage)(ini_pan_margin,ini_tilt_margin));
01916     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetMarginMessage");
01917     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01918   }
01919  }
01920  return 1;
01921 #ifndef TOLUA_RELEASE
01922  tolua_lerror:
01923  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01924  return 0;
01925 #endif
01926 }
01927 #endif //#ifndef TOLUA_DISABLE
01928 
01929 /* method: new of class  SetMarginMessage */
01930 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new01
01931 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new01(lua_State* tolua_S)
01932 {
01933  tolua_Error tolua_err;
01934  if (
01935      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
01936      !tolua_isnoobj(tolua_S,2,&tolua_err)
01937  )
01938   goto tolua_lerror;
01939  else
01940  {
01941   {
01942    fawkes::PanTiltInterface::SetMarginMessage* tolua_ret = (fawkes::PanTiltInterface::SetMarginMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetMarginMessage)());
01943     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetMarginMessage");
01944   }
01945  }
01946  return 1;
01947 tolua_lerror:
01948  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new00(tolua_S);
01949 }
01950 #endif //#ifndef TOLUA_DISABLE
01951 
01952 /* method: new_local of class  SetMarginMessage */
01953 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new01_local
01954 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new01_local(lua_State* tolua_S)
01955 {
01956  tolua_Error tolua_err;
01957  if (
01958      !tolua_isusertable(tolua_S,1,"fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
01959      !tolua_isnoobj(tolua_S,2,&tolua_err)
01960  )
01961   goto tolua_lerror;
01962  else
01963  {
01964   {
01965    fawkes::PanTiltInterface::SetMarginMessage* tolua_ret = (fawkes::PanTiltInterface::SetMarginMessage*)  Mtolua_new((fawkes::PanTiltInterface::SetMarginMessage)());
01966     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::PanTiltInterface::SetMarginMessage");
01967     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01968   }
01969  }
01970  return 1;
01971 tolua_lerror:
01972  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new00_local(tolua_S);
01973 }
01974 #endif //#ifndef TOLUA_DISABLE
01975 
01976 /* method: delete of class  SetMarginMessage */
01977 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_delete00
01978 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_delete00(lua_State* tolua_S)
01979 {
01980 #ifndef TOLUA_RELEASE
01981  tolua_Error tolua_err;
01982  if (
01983      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
01984      !tolua_isnoobj(tolua_S,2,&tolua_err)
01985  )
01986   goto tolua_lerror;
01987  else
01988 #endif
01989  {
01990   fawkes::PanTiltInterface::SetMarginMessage* self = (fawkes::PanTiltInterface::SetMarginMessage*)  tolua_tousertype(tolua_S,1,0);
01991 #ifndef TOLUA_RELEASE
01992   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01993 #endif
01994   Mtolua_delete(self);
01995  }
01996  return 0;
01997 #ifndef TOLUA_RELEASE
01998  tolua_lerror:
01999  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02000  return 0;
02001 #endif
02002 }
02003 #endif //#ifndef TOLUA_DISABLE
02004 
02005 /* method: pan_margin of class  SetMarginMessage */
02006 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_pan_margin00
02007 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_pan_margin00(lua_State* tolua_S)
02008 {
02009 #ifndef TOLUA_RELEASE
02010  tolua_Error tolua_err;
02011  if (
02012      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
02013      !tolua_isnoobj(tolua_S,2,&tolua_err)
02014  )
02015   goto tolua_lerror;
02016  else
02017 #endif
02018  {
02019   fawkes::PanTiltInterface::SetMarginMessage* self = (fawkes::PanTiltInterface::SetMarginMessage*)  tolua_tousertype(tolua_S,1,0);
02020 #ifndef TOLUA_RELEASE
02021   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pan_margin'", NULL);
02022 #endif
02023   {
02024    float tolua_ret = (float)  self->pan_margin();
02025    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02026   }
02027  }
02028  return 1;
02029 #ifndef TOLUA_RELEASE
02030  tolua_lerror:
02031  tolua_error(tolua_S,"#ferror in function 'pan_margin'.",&tolua_err);
02032  return 0;
02033 #endif
02034 }
02035 #endif //#ifndef TOLUA_DISABLE
02036 
02037 /* method: set_pan_margin of class  SetMarginMessage */
02038 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_set_pan_margin00
02039 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_set_pan_margin00(lua_State* tolua_S)
02040 {
02041 #ifndef TOLUA_RELEASE
02042  tolua_Error tolua_err;
02043  if (
02044      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
02045      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02046      !tolua_isnoobj(tolua_S,3,&tolua_err)
02047  )
02048   goto tolua_lerror;
02049  else
02050 #endif
02051  {
02052   fawkes::PanTiltInterface::SetMarginMessage* self = (fawkes::PanTiltInterface::SetMarginMessage*)  tolua_tousertype(tolua_S,1,0);
02053   const float new_pan_margin = ((const float)  tolua_tonumber(tolua_S,2,0));
02054 #ifndef TOLUA_RELEASE
02055   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_pan_margin'", NULL);
02056 #endif
02057   {
02058    self->set_pan_margin(new_pan_margin);
02059   }
02060  }
02061  return 0;
02062 #ifndef TOLUA_RELEASE
02063  tolua_lerror:
02064  tolua_error(tolua_S,"#ferror in function 'set_pan_margin'.",&tolua_err);
02065  return 0;
02066 #endif
02067 }
02068 #endif //#ifndef TOLUA_DISABLE
02069 
02070 /* method: maxlenof_pan_margin of class  SetMarginMessage */
02071 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_maxlenof_pan_margin00
02072 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_maxlenof_pan_margin00(lua_State* tolua_S)
02073 {
02074 #ifndef TOLUA_RELEASE
02075  tolua_Error tolua_err;
02076  if (
02077      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
02078      !tolua_isnoobj(tolua_S,2,&tolua_err)
02079  )
02080   goto tolua_lerror;
02081  else
02082 #endif
02083  {
02084   const fawkes::PanTiltInterface::SetMarginMessage* self = (const fawkes::PanTiltInterface::SetMarginMessage*)  tolua_tousertype(tolua_S,1,0);
02085 #ifndef TOLUA_RELEASE
02086   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_pan_margin'", NULL);
02087 #endif
02088   {
02089    int tolua_ret = (int)  self->maxlenof_pan_margin();
02090    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02091   }
02092  }
02093  return 1;
02094 #ifndef TOLUA_RELEASE
02095  tolua_lerror:
02096  tolua_error(tolua_S,"#ferror in function 'maxlenof_pan_margin'.",&tolua_err);
02097  return 0;
02098 #endif
02099 }
02100 #endif //#ifndef TOLUA_DISABLE
02101 
02102 /* method: tilt_margin of class  SetMarginMessage */
02103 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_tilt_margin00
02104 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_tilt_margin00(lua_State* tolua_S)
02105 {
02106 #ifndef TOLUA_RELEASE
02107  tolua_Error tolua_err;
02108  if (
02109      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
02110      !tolua_isnoobj(tolua_S,2,&tolua_err)
02111  )
02112   goto tolua_lerror;
02113  else
02114 #endif
02115  {
02116   fawkes::PanTiltInterface::SetMarginMessage* self = (fawkes::PanTiltInterface::SetMarginMessage*)  tolua_tousertype(tolua_S,1,0);
02117 #ifndef TOLUA_RELEASE
02118   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tilt_margin'", NULL);
02119 #endif
02120   {
02121    float tolua_ret = (float)  self->tilt_margin();
02122    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02123   }
02124  }
02125  return 1;
02126 #ifndef TOLUA_RELEASE
02127  tolua_lerror:
02128  tolua_error(tolua_S,"#ferror in function 'tilt_margin'.",&tolua_err);
02129  return 0;
02130 #endif
02131 }
02132 #endif //#ifndef TOLUA_DISABLE
02133 
02134 /* method: set_tilt_margin of class  SetMarginMessage */
02135 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_set_tilt_margin00
02136 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_set_tilt_margin00(lua_State* tolua_S)
02137 {
02138 #ifndef TOLUA_RELEASE
02139  tolua_Error tolua_err;
02140  if (
02141      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
02142      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02143      !tolua_isnoobj(tolua_S,3,&tolua_err)
02144  )
02145   goto tolua_lerror;
02146  else
02147 #endif
02148  {
02149   fawkes::PanTiltInterface::SetMarginMessage* self = (fawkes::PanTiltInterface::SetMarginMessage*)  tolua_tousertype(tolua_S,1,0);
02150   const float new_tilt_margin = ((const float)  tolua_tonumber(tolua_S,2,0));
02151 #ifndef TOLUA_RELEASE
02152   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_tilt_margin'", NULL);
02153 #endif
02154   {
02155    self->set_tilt_margin(new_tilt_margin);
02156   }
02157  }
02158  return 0;
02159 #ifndef TOLUA_RELEASE
02160  tolua_lerror:
02161  tolua_error(tolua_S,"#ferror in function 'set_tilt_margin'.",&tolua_err);
02162  return 0;
02163 #endif
02164 }
02165 #endif //#ifndef TOLUA_DISABLE
02166 
02167 /* method: maxlenof_tilt_margin of class  SetMarginMessage */
02168 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_maxlenof_tilt_margin00
02169 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_maxlenof_tilt_margin00(lua_State* tolua_S)
02170 {
02171 #ifndef TOLUA_RELEASE
02172  tolua_Error tolua_err;
02173  if (
02174      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface::SetMarginMessage",0,&tolua_err) ||
02175      !tolua_isnoobj(tolua_S,2,&tolua_err)
02176  )
02177   goto tolua_lerror;
02178  else
02179 #endif
02180  {
02181   const fawkes::PanTiltInterface::SetMarginMessage* self = (const fawkes::PanTiltInterface::SetMarginMessage*)  tolua_tousertype(tolua_S,1,0);
02182 #ifndef TOLUA_RELEASE
02183   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_tilt_margin'", NULL);
02184 #endif
02185   {
02186    int tolua_ret = (int)  self->maxlenof_tilt_margin();
02187    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02188   }
02189  }
02190  return 1;
02191 #ifndef TOLUA_RELEASE
02192  tolua_lerror:
02193  tolua_error(tolua_S,"#ferror in function 'maxlenof_tilt_margin'.",&tolua_err);
02194  return 0;
02195 #endif
02196 }
02197 #endif //#ifndef TOLUA_DISABLE
02198 
02199 /* method: flags of class  fawkes::PanTiltInterface */
02200 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_flags00
02201 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_flags00(lua_State* tolua_S)
02202 {
02203 #ifndef TOLUA_RELEASE
02204  tolua_Error tolua_err;
02205  if (
02206      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02207      !tolua_isnoobj(tolua_S,2,&tolua_err)
02208  )
02209   goto tolua_lerror;
02210  else
02211 #endif
02212  {
02213   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02214 #ifndef TOLUA_RELEASE
02215   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'flags'", NULL);
02216 #endif
02217   {
02218    unsigned int tolua_ret = (unsigned int)  self->flags();
02219    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02220   }
02221  }
02222  return 1;
02223 #ifndef TOLUA_RELEASE
02224  tolua_lerror:
02225  tolua_error(tolua_S,"#ferror in function 'flags'.",&tolua_err);
02226  return 0;
02227 #endif
02228 }
02229 #endif //#ifndef TOLUA_DISABLE
02230 
02231 /* method: set_flags of class  fawkes::PanTiltInterface */
02232 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_flags00
02233 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_flags00(lua_State* tolua_S)
02234 {
02235 #ifndef TOLUA_RELEASE
02236  tolua_Error tolua_err;
02237  if (
02238      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02239      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02240      !tolua_isnoobj(tolua_S,3,&tolua_err)
02241  )
02242   goto tolua_lerror;
02243  else
02244 #endif
02245  {
02246   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02247   unsigned const int new_flags = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
02248 #ifndef TOLUA_RELEASE
02249   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_flags'", NULL);
02250 #endif
02251   {
02252    self->set_flags(new_flags);
02253   }
02254  }
02255  return 0;
02256 #ifndef TOLUA_RELEASE
02257  tolua_lerror:
02258  tolua_error(tolua_S,"#ferror in function 'set_flags'.",&tolua_err);
02259  return 0;
02260 #endif
02261 }
02262 #endif //#ifndef TOLUA_DISABLE
02263 
02264 /* method: maxlenof_flags of class  fawkes::PanTiltInterface */
02265 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_flags00
02266 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_flags00(lua_State* tolua_S)
02267 {
02268 #ifndef TOLUA_RELEASE
02269  tolua_Error tolua_err;
02270  if (
02271      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
02272      !tolua_isnoobj(tolua_S,2,&tolua_err)
02273  )
02274   goto tolua_lerror;
02275  else
02276 #endif
02277  {
02278   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02279 #ifndef TOLUA_RELEASE
02280   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_flags'", NULL);
02281 #endif
02282   {
02283    int tolua_ret = (int)  self->maxlenof_flags();
02284    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02285   }
02286  }
02287  return 1;
02288 #ifndef TOLUA_RELEASE
02289  tolua_lerror:
02290  tolua_error(tolua_S,"#ferror in function 'maxlenof_flags'.",&tolua_err);
02291  return 0;
02292 #endif
02293 }
02294 #endif //#ifndef TOLUA_DISABLE
02295 
02296 /* method: pan of class  fawkes::PanTiltInterface */
02297 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_pan00
02298 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_pan00(lua_State* tolua_S)
02299 {
02300 #ifndef TOLUA_RELEASE
02301  tolua_Error tolua_err;
02302  if (
02303      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02304      !tolua_isnoobj(tolua_S,2,&tolua_err)
02305  )
02306   goto tolua_lerror;
02307  else
02308 #endif
02309  {
02310   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02311 #ifndef TOLUA_RELEASE
02312   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pan'", NULL);
02313 #endif
02314   {
02315    float tolua_ret = (float)  self->pan();
02316    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02317   }
02318  }
02319  return 1;
02320 #ifndef TOLUA_RELEASE
02321  tolua_lerror:
02322  tolua_error(tolua_S,"#ferror in function 'pan'.",&tolua_err);
02323  return 0;
02324 #endif
02325 }
02326 #endif //#ifndef TOLUA_DISABLE
02327 
02328 /* method: set_pan of class  fawkes::PanTiltInterface */
02329 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_pan00
02330 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_pan00(lua_State* tolua_S)
02331 {
02332 #ifndef TOLUA_RELEASE
02333  tolua_Error tolua_err;
02334  if (
02335      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02336      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02337      !tolua_isnoobj(tolua_S,3,&tolua_err)
02338  )
02339   goto tolua_lerror;
02340  else
02341 #endif
02342  {
02343   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02344   const float new_pan = ((const float)  tolua_tonumber(tolua_S,2,0));
02345 #ifndef TOLUA_RELEASE
02346   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_pan'", NULL);
02347 #endif
02348   {
02349    self->set_pan(new_pan);
02350   }
02351  }
02352  return 0;
02353 #ifndef TOLUA_RELEASE
02354  tolua_lerror:
02355  tolua_error(tolua_S,"#ferror in function 'set_pan'.",&tolua_err);
02356  return 0;
02357 #endif
02358 }
02359 #endif //#ifndef TOLUA_DISABLE
02360 
02361 /* method: maxlenof_pan of class  fawkes::PanTiltInterface */
02362 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_pan00
02363 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_pan00(lua_State* tolua_S)
02364 {
02365 #ifndef TOLUA_RELEASE
02366  tolua_Error tolua_err;
02367  if (
02368      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
02369      !tolua_isnoobj(tolua_S,2,&tolua_err)
02370  )
02371   goto tolua_lerror;
02372  else
02373 #endif
02374  {
02375   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02376 #ifndef TOLUA_RELEASE
02377   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_pan'", NULL);
02378 #endif
02379   {
02380    int tolua_ret = (int)  self->maxlenof_pan();
02381    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02382   }
02383  }
02384  return 1;
02385 #ifndef TOLUA_RELEASE
02386  tolua_lerror:
02387  tolua_error(tolua_S,"#ferror in function 'maxlenof_pan'.",&tolua_err);
02388  return 0;
02389 #endif
02390 }
02391 #endif //#ifndef TOLUA_DISABLE
02392 
02393 /* method: tilt of class  fawkes::PanTiltInterface */
02394 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_tilt00
02395 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_tilt00(lua_State* tolua_S)
02396 {
02397 #ifndef TOLUA_RELEASE
02398  tolua_Error tolua_err;
02399  if (
02400      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02401      !tolua_isnoobj(tolua_S,2,&tolua_err)
02402  )
02403   goto tolua_lerror;
02404  else
02405 #endif
02406  {
02407   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02408 #ifndef TOLUA_RELEASE
02409   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tilt'", NULL);
02410 #endif
02411   {
02412    float tolua_ret = (float)  self->tilt();
02413    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02414   }
02415  }
02416  return 1;
02417 #ifndef TOLUA_RELEASE
02418  tolua_lerror:
02419  tolua_error(tolua_S,"#ferror in function 'tilt'.",&tolua_err);
02420  return 0;
02421 #endif
02422 }
02423 #endif //#ifndef TOLUA_DISABLE
02424 
02425 /* method: set_tilt of class  fawkes::PanTiltInterface */
02426 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_tilt00
02427 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_tilt00(lua_State* tolua_S)
02428 {
02429 #ifndef TOLUA_RELEASE
02430  tolua_Error tolua_err;
02431  if (
02432      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02433      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02434      !tolua_isnoobj(tolua_S,3,&tolua_err)
02435  )
02436   goto tolua_lerror;
02437  else
02438 #endif
02439  {
02440   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02441   const float new_tilt = ((const float)  tolua_tonumber(tolua_S,2,0));
02442 #ifndef TOLUA_RELEASE
02443   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_tilt'", NULL);
02444 #endif
02445   {
02446    self->set_tilt(new_tilt);
02447   }
02448  }
02449  return 0;
02450 #ifndef TOLUA_RELEASE
02451  tolua_lerror:
02452  tolua_error(tolua_S,"#ferror in function 'set_tilt'.",&tolua_err);
02453  return 0;
02454 #endif
02455 }
02456 #endif //#ifndef TOLUA_DISABLE
02457 
02458 /* method: maxlenof_tilt of class  fawkes::PanTiltInterface */
02459 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_tilt00
02460 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_tilt00(lua_State* tolua_S)
02461 {
02462 #ifndef TOLUA_RELEASE
02463  tolua_Error tolua_err;
02464  if (
02465      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
02466      !tolua_isnoobj(tolua_S,2,&tolua_err)
02467  )
02468   goto tolua_lerror;
02469  else
02470 #endif
02471  {
02472   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02473 #ifndef TOLUA_RELEASE
02474   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_tilt'", NULL);
02475 #endif
02476   {
02477    int tolua_ret = (int)  self->maxlenof_tilt();
02478    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02479   }
02480  }
02481  return 1;
02482 #ifndef TOLUA_RELEASE
02483  tolua_lerror:
02484  tolua_error(tolua_S,"#ferror in function 'maxlenof_tilt'.",&tolua_err);
02485  return 0;
02486 #endif
02487 }
02488 #endif //#ifndef TOLUA_DISABLE
02489 
02490 /* method: msgid of class  fawkes::PanTiltInterface */
02491 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgid00
02492 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgid00(lua_State* tolua_S)
02493 {
02494 #ifndef TOLUA_RELEASE
02495  tolua_Error tolua_err;
02496  if (
02497      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02498      !tolua_isnoobj(tolua_S,2,&tolua_err)
02499  )
02500   goto tolua_lerror;
02501  else
02502 #endif
02503  {
02504   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02505 #ifndef TOLUA_RELEASE
02506   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgid'", NULL);
02507 #endif
02508   {
02509    unsigned int tolua_ret = (unsigned int)  self->msgid();
02510    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02511   }
02512  }
02513  return 1;
02514 #ifndef TOLUA_RELEASE
02515  tolua_lerror:
02516  tolua_error(tolua_S,"#ferror in function 'msgid'.",&tolua_err);
02517  return 0;
02518 #endif
02519 }
02520 #endif //#ifndef TOLUA_DISABLE
02521 
02522 /* method: set_msgid of class  fawkes::PanTiltInterface */
02523 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_msgid00
02524 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_msgid00(lua_State* tolua_S)
02525 {
02526 #ifndef TOLUA_RELEASE
02527  tolua_Error tolua_err;
02528  if (
02529      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02530      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02531      !tolua_isnoobj(tolua_S,3,&tolua_err)
02532  )
02533   goto tolua_lerror;
02534  else
02535 #endif
02536  {
02537   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02538   unsigned const int new_msgid = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
02539 #ifndef TOLUA_RELEASE
02540   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_msgid'", NULL);
02541 #endif
02542   {
02543    self->set_msgid(new_msgid);
02544   }
02545  }
02546  return 0;
02547 #ifndef TOLUA_RELEASE
02548  tolua_lerror:
02549  tolua_error(tolua_S,"#ferror in function 'set_msgid'.",&tolua_err);
02550  return 0;
02551 #endif
02552 }
02553 #endif //#ifndef TOLUA_DISABLE
02554 
02555 /* method: maxlenof_msgid of class  fawkes::PanTiltInterface */
02556 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_msgid00
02557 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_msgid00(lua_State* tolua_S)
02558 {
02559 #ifndef TOLUA_RELEASE
02560  tolua_Error tolua_err;
02561  if (
02562      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
02563      !tolua_isnoobj(tolua_S,2,&tolua_err)
02564  )
02565   goto tolua_lerror;
02566  else
02567 #endif
02568  {
02569   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02570 #ifndef TOLUA_RELEASE
02571   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_msgid'", NULL);
02572 #endif
02573   {
02574    int tolua_ret = (int)  self->maxlenof_msgid();
02575    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02576   }
02577  }
02578  return 1;
02579 #ifndef TOLUA_RELEASE
02580  tolua_lerror:
02581  tolua_error(tolua_S,"#ferror in function 'maxlenof_msgid'.",&tolua_err);
02582  return 0;
02583 #endif
02584 }
02585 #endif //#ifndef TOLUA_DISABLE
02586 
02587 /* method: is_final of class  fawkes::PanTiltInterface */
02588 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_final00
02589 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_final00(lua_State* tolua_S)
02590 {
02591 #ifndef TOLUA_RELEASE
02592  tolua_Error tolua_err;
02593  if (
02594      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02595      !tolua_isnoobj(tolua_S,2,&tolua_err)
02596  )
02597   goto tolua_lerror;
02598  else
02599 #endif
02600  {
02601   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02602 #ifndef TOLUA_RELEASE
02603   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_final'", NULL);
02604 #endif
02605   {
02606    bool tolua_ret = (bool)  self->is_final();
02607    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02608   }
02609  }
02610  return 1;
02611 #ifndef TOLUA_RELEASE
02612  tolua_lerror:
02613  tolua_error(tolua_S,"#ferror in function 'is_final'.",&tolua_err);
02614  return 0;
02615 #endif
02616 }
02617 #endif //#ifndef TOLUA_DISABLE
02618 
02619 /* method: set_final of class  fawkes::PanTiltInterface */
02620 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_final00
02621 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_final00(lua_State* tolua_S)
02622 {
02623 #ifndef TOLUA_RELEASE
02624  tolua_Error tolua_err;
02625  if (
02626      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02627      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02628      !tolua_isnoobj(tolua_S,3,&tolua_err)
02629  )
02630   goto tolua_lerror;
02631  else
02632 #endif
02633  {
02634   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02635   const bool new_final = ((const bool)  tolua_toboolean(tolua_S,2,0));
02636 #ifndef TOLUA_RELEASE
02637   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_final'", NULL);
02638 #endif
02639   {
02640    self->set_final(new_final);
02641   }
02642  }
02643  return 0;
02644 #ifndef TOLUA_RELEASE
02645  tolua_lerror:
02646  tolua_error(tolua_S,"#ferror in function 'set_final'.",&tolua_err);
02647  return 0;
02648 #endif
02649 }
02650 #endif //#ifndef TOLUA_DISABLE
02651 
02652 /* method: maxlenof_final of class  fawkes::PanTiltInterface */
02653 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_final00
02654 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_final00(lua_State* tolua_S)
02655 {
02656 #ifndef TOLUA_RELEASE
02657  tolua_Error tolua_err;
02658  if (
02659      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
02660      !tolua_isnoobj(tolua_S,2,&tolua_err)
02661  )
02662   goto tolua_lerror;
02663  else
02664 #endif
02665  {
02666   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02667 #ifndef TOLUA_RELEASE
02668   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_final'", NULL);
02669 #endif
02670   {
02671    int tolua_ret = (int)  self->maxlenof_final();
02672    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02673   }
02674  }
02675  return 1;
02676 #ifndef TOLUA_RELEASE
02677  tolua_lerror:
02678  tolua_error(tolua_S,"#ferror in function 'maxlenof_final'.",&tolua_err);
02679  return 0;
02680 #endif
02681 }
02682 #endif //#ifndef TOLUA_DISABLE
02683 
02684 /* method: error_code of class  fawkes::PanTiltInterface */
02685 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_error_code00
02686 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_error_code00(lua_State* tolua_S)
02687 {
02688 #ifndef TOLUA_RELEASE
02689  tolua_Error tolua_err;
02690  if (
02691      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02692      !tolua_isnoobj(tolua_S,2,&tolua_err)
02693  )
02694   goto tolua_lerror;
02695  else
02696 #endif
02697  {
02698   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02699 #ifndef TOLUA_RELEASE
02700   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'error_code'", NULL);
02701 #endif
02702   {
02703    unsigned int tolua_ret = (unsigned int)  self->error_code();
02704    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02705   }
02706  }
02707  return 1;
02708 #ifndef TOLUA_RELEASE
02709  tolua_lerror:
02710  tolua_error(tolua_S,"#ferror in function 'error_code'.",&tolua_err);
02711  return 0;
02712 #endif
02713 }
02714 #endif //#ifndef TOLUA_DISABLE
02715 
02716 /* method: set_error_code of class  fawkes::PanTiltInterface */
02717 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_error_code00
02718 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_error_code00(lua_State* tolua_S)
02719 {
02720 #ifndef TOLUA_RELEASE
02721  tolua_Error tolua_err;
02722  if (
02723      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02724      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02725      !tolua_isnoobj(tolua_S,3,&tolua_err)
02726  )
02727   goto tolua_lerror;
02728  else
02729 #endif
02730  {
02731   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02732   unsigned const int new_error_code = ((unsigned const int)  tolua_tonumber(tolua_S,2,0));
02733 #ifndef TOLUA_RELEASE
02734   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_error_code'", NULL);
02735 #endif
02736   {
02737    self->set_error_code(new_error_code);
02738   }
02739  }
02740  return 0;
02741 #ifndef TOLUA_RELEASE
02742  tolua_lerror:
02743  tolua_error(tolua_S,"#ferror in function 'set_error_code'.",&tolua_err);
02744  return 0;
02745 #endif
02746 }
02747 #endif //#ifndef TOLUA_DISABLE
02748 
02749 /* method: maxlenof_error_code of class  fawkes::PanTiltInterface */
02750 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_error_code00
02751 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_error_code00(lua_State* tolua_S)
02752 {
02753 #ifndef TOLUA_RELEASE
02754  tolua_Error tolua_err;
02755  if (
02756      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
02757      !tolua_isnoobj(tolua_S,2,&tolua_err)
02758  )
02759   goto tolua_lerror;
02760  else
02761 #endif
02762  {
02763   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02764 #ifndef TOLUA_RELEASE
02765   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_error_code'", NULL);
02766 #endif
02767   {
02768    int tolua_ret = (int)  self->maxlenof_error_code();
02769    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02770   }
02771  }
02772  return 1;
02773 #ifndef TOLUA_RELEASE
02774  tolua_lerror:
02775  tolua_error(tolua_S,"#ferror in function 'maxlenof_error_code'.",&tolua_err);
02776  return 0;
02777 #endif
02778 }
02779 #endif //#ifndef TOLUA_DISABLE
02780 
02781 /* method: is_enabled of class  fawkes::PanTiltInterface */
02782 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_enabled00
02783 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_enabled00(lua_State* tolua_S)
02784 {
02785 #ifndef TOLUA_RELEASE
02786  tolua_Error tolua_err;
02787  if (
02788      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02789      !tolua_isnoobj(tolua_S,2,&tolua_err)
02790  )
02791   goto tolua_lerror;
02792  else
02793 #endif
02794  {
02795   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02796 #ifndef TOLUA_RELEASE
02797   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'", NULL);
02798 #endif
02799   {
02800    bool tolua_ret = (bool)  self->is_enabled();
02801    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02802   }
02803  }
02804  return 1;
02805 #ifndef TOLUA_RELEASE
02806  tolua_lerror:
02807  tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err);
02808  return 0;
02809 #endif
02810 }
02811 #endif //#ifndef TOLUA_DISABLE
02812 
02813 /* method: set_enabled of class  fawkes::PanTiltInterface */
02814 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_enabled00
02815 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_enabled00(lua_State* tolua_S)
02816 {
02817 #ifndef TOLUA_RELEASE
02818  tolua_Error tolua_err;
02819  if (
02820      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02821      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02822      !tolua_isnoobj(tolua_S,3,&tolua_err)
02823  )
02824   goto tolua_lerror;
02825  else
02826 #endif
02827  {
02828   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02829   const bool new_enabled = ((const bool)  tolua_toboolean(tolua_S,2,0));
02830 #ifndef TOLUA_RELEASE
02831   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'", NULL);
02832 #endif
02833   {
02834    self->set_enabled(new_enabled);
02835   }
02836  }
02837  return 0;
02838 #ifndef TOLUA_RELEASE
02839  tolua_lerror:
02840  tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err);
02841  return 0;
02842 #endif
02843 }
02844 #endif //#ifndef TOLUA_DISABLE
02845 
02846 /* method: maxlenof_enabled of class  fawkes::PanTiltInterface */
02847 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_enabled00
02848 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_enabled00(lua_State* tolua_S)
02849 {
02850 #ifndef TOLUA_RELEASE
02851  tolua_Error tolua_err;
02852  if (
02853      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
02854      !tolua_isnoobj(tolua_S,2,&tolua_err)
02855  )
02856   goto tolua_lerror;
02857  else
02858 #endif
02859  {
02860   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02861 #ifndef TOLUA_RELEASE
02862   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'", NULL);
02863 #endif
02864   {
02865    int tolua_ret = (int)  self->maxlenof_enabled();
02866    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02867   }
02868  }
02869  return 1;
02870 #ifndef TOLUA_RELEASE
02871  tolua_lerror:
02872  tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err);
02873  return 0;
02874 #endif
02875 }
02876 #endif //#ifndef TOLUA_DISABLE
02877 
02878 /* method: is_calibrated of class  fawkes::PanTiltInterface */
02879 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_calibrated00
02880 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_calibrated00(lua_State* tolua_S)
02881 {
02882 #ifndef TOLUA_RELEASE
02883  tolua_Error tolua_err;
02884  if (
02885      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02886      !tolua_isnoobj(tolua_S,2,&tolua_err)
02887  )
02888   goto tolua_lerror;
02889  else
02890 #endif
02891  {
02892   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02893 #ifndef TOLUA_RELEASE
02894   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_calibrated'", NULL);
02895 #endif
02896   {
02897    bool tolua_ret = (bool)  self->is_calibrated();
02898    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02899   }
02900  }
02901  return 1;
02902 #ifndef TOLUA_RELEASE
02903  tolua_lerror:
02904  tolua_error(tolua_S,"#ferror in function 'is_calibrated'.",&tolua_err);
02905  return 0;
02906 #endif
02907 }
02908 #endif //#ifndef TOLUA_DISABLE
02909 
02910 /* method: set_calibrated of class  fawkes::PanTiltInterface */
02911 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_calibrated00
02912 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_calibrated00(lua_State* tolua_S)
02913 {
02914 #ifndef TOLUA_RELEASE
02915  tolua_Error tolua_err;
02916  if (
02917      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02918      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
02919      !tolua_isnoobj(tolua_S,3,&tolua_err)
02920  )
02921   goto tolua_lerror;
02922  else
02923 #endif
02924  {
02925   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02926   const bool new_calibrated = ((const bool)  tolua_toboolean(tolua_S,2,0));
02927 #ifndef TOLUA_RELEASE
02928   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_calibrated'", NULL);
02929 #endif
02930   {
02931    self->set_calibrated(new_calibrated);
02932   }
02933  }
02934  return 0;
02935 #ifndef TOLUA_RELEASE
02936  tolua_lerror:
02937  tolua_error(tolua_S,"#ferror in function 'set_calibrated'.",&tolua_err);
02938  return 0;
02939 #endif
02940 }
02941 #endif //#ifndef TOLUA_DISABLE
02942 
02943 /* method: maxlenof_calibrated of class  fawkes::PanTiltInterface */
02944 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_calibrated00
02945 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_calibrated00(lua_State* tolua_S)
02946 {
02947 #ifndef TOLUA_RELEASE
02948  tolua_Error tolua_err;
02949  if (
02950      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
02951      !tolua_isnoobj(tolua_S,2,&tolua_err)
02952  )
02953   goto tolua_lerror;
02954  else
02955 #endif
02956  {
02957   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02958 #ifndef TOLUA_RELEASE
02959   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_calibrated'", NULL);
02960 #endif
02961   {
02962    int tolua_ret = (int)  self->maxlenof_calibrated();
02963    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02964   }
02965  }
02966  return 1;
02967 #ifndef TOLUA_RELEASE
02968  tolua_lerror:
02969  tolua_error(tolua_S,"#ferror in function 'maxlenof_calibrated'.",&tolua_err);
02970  return 0;
02971 #endif
02972 }
02973 #endif //#ifndef TOLUA_DISABLE
02974 
02975 /* method: min_pan of class  fawkes::PanTiltInterface */
02976 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_min_pan00
02977 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_min_pan00(lua_State* tolua_S)
02978 {
02979 #ifndef TOLUA_RELEASE
02980  tolua_Error tolua_err;
02981  if (
02982      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
02983      !tolua_isnoobj(tolua_S,2,&tolua_err)
02984  )
02985   goto tolua_lerror;
02986  else
02987 #endif
02988  {
02989   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
02990 #ifndef TOLUA_RELEASE
02991   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'min_pan'", NULL);
02992 #endif
02993   {
02994    float tolua_ret = (float)  self->min_pan();
02995    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02996   }
02997  }
02998  return 1;
02999 #ifndef TOLUA_RELEASE
03000  tolua_lerror:
03001  tolua_error(tolua_S,"#ferror in function 'min_pan'.",&tolua_err);
03002  return 0;
03003 #endif
03004 }
03005 #endif //#ifndef TOLUA_DISABLE
03006 
03007 /* method: set_min_pan of class  fawkes::PanTiltInterface */
03008 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_min_pan00
03009 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_min_pan00(lua_State* tolua_S)
03010 {
03011 #ifndef TOLUA_RELEASE
03012  tolua_Error tolua_err;
03013  if (
03014      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03015      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03016      !tolua_isnoobj(tolua_S,3,&tolua_err)
03017  )
03018   goto tolua_lerror;
03019  else
03020 #endif
03021  {
03022   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03023   const float new_min_pan = ((const float)  tolua_tonumber(tolua_S,2,0));
03024 #ifndef TOLUA_RELEASE
03025   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_min_pan'", NULL);
03026 #endif
03027   {
03028    self->set_min_pan(new_min_pan);
03029   }
03030  }
03031  return 0;
03032 #ifndef TOLUA_RELEASE
03033  tolua_lerror:
03034  tolua_error(tolua_S,"#ferror in function 'set_min_pan'.",&tolua_err);
03035  return 0;
03036 #endif
03037 }
03038 #endif //#ifndef TOLUA_DISABLE
03039 
03040 /* method: maxlenof_min_pan of class  fawkes::PanTiltInterface */
03041 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_min_pan00
03042 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_min_pan00(lua_State* tolua_S)
03043 {
03044 #ifndef TOLUA_RELEASE
03045  tolua_Error tolua_err;
03046  if (
03047      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03048      !tolua_isnoobj(tolua_S,2,&tolua_err)
03049  )
03050   goto tolua_lerror;
03051  else
03052 #endif
03053  {
03054   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03055 #ifndef TOLUA_RELEASE
03056   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_min_pan'", NULL);
03057 #endif
03058   {
03059    int tolua_ret = (int)  self->maxlenof_min_pan();
03060    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03061   }
03062  }
03063  return 1;
03064 #ifndef TOLUA_RELEASE
03065  tolua_lerror:
03066  tolua_error(tolua_S,"#ferror in function 'maxlenof_min_pan'.",&tolua_err);
03067  return 0;
03068 #endif
03069 }
03070 #endif //#ifndef TOLUA_DISABLE
03071 
03072 /* method: max_pan of class  fawkes::PanTiltInterface */
03073 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_pan00
03074 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_pan00(lua_State* tolua_S)
03075 {
03076 #ifndef TOLUA_RELEASE
03077  tolua_Error tolua_err;
03078  if (
03079      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03080      !tolua_isnoobj(tolua_S,2,&tolua_err)
03081  )
03082   goto tolua_lerror;
03083  else
03084 #endif
03085  {
03086   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03087 #ifndef TOLUA_RELEASE
03088   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_pan'", NULL);
03089 #endif
03090   {
03091    float tolua_ret = (float)  self->max_pan();
03092    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03093   }
03094  }
03095  return 1;
03096 #ifndef TOLUA_RELEASE
03097  tolua_lerror:
03098  tolua_error(tolua_S,"#ferror in function 'max_pan'.",&tolua_err);
03099  return 0;
03100 #endif
03101 }
03102 #endif //#ifndef TOLUA_DISABLE
03103 
03104 /* method: set_max_pan of class  fawkes::PanTiltInterface */
03105 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_pan00
03106 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_pan00(lua_State* tolua_S)
03107 {
03108 #ifndef TOLUA_RELEASE
03109  tolua_Error tolua_err;
03110  if (
03111      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03112      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03113      !tolua_isnoobj(tolua_S,3,&tolua_err)
03114  )
03115   goto tolua_lerror;
03116  else
03117 #endif
03118  {
03119   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03120   const float new_max_pan = ((const float)  tolua_tonumber(tolua_S,2,0));
03121 #ifndef TOLUA_RELEASE
03122   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_pan'", NULL);
03123 #endif
03124   {
03125    self->set_max_pan(new_max_pan);
03126   }
03127  }
03128  return 0;
03129 #ifndef TOLUA_RELEASE
03130  tolua_lerror:
03131  tolua_error(tolua_S,"#ferror in function 'set_max_pan'.",&tolua_err);
03132  return 0;
03133 #endif
03134 }
03135 #endif //#ifndef TOLUA_DISABLE
03136 
03137 /* method: maxlenof_max_pan of class  fawkes::PanTiltInterface */
03138 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_pan00
03139 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_pan00(lua_State* tolua_S)
03140 {
03141 #ifndef TOLUA_RELEASE
03142  tolua_Error tolua_err;
03143  if (
03144      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03145      !tolua_isnoobj(tolua_S,2,&tolua_err)
03146  )
03147   goto tolua_lerror;
03148  else
03149 #endif
03150  {
03151   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03152 #ifndef TOLUA_RELEASE
03153   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_pan'", NULL);
03154 #endif
03155   {
03156    int tolua_ret = (int)  self->maxlenof_max_pan();
03157    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03158   }
03159  }
03160  return 1;
03161 #ifndef TOLUA_RELEASE
03162  tolua_lerror:
03163  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_pan'.",&tolua_err);
03164  return 0;
03165 #endif
03166 }
03167 #endif //#ifndef TOLUA_DISABLE
03168 
03169 /* method: min_tilt of class  fawkes::PanTiltInterface */
03170 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_min_tilt00
03171 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_min_tilt00(lua_State* tolua_S)
03172 {
03173 #ifndef TOLUA_RELEASE
03174  tolua_Error tolua_err;
03175  if (
03176      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03177      !tolua_isnoobj(tolua_S,2,&tolua_err)
03178  )
03179   goto tolua_lerror;
03180  else
03181 #endif
03182  {
03183   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03184 #ifndef TOLUA_RELEASE
03185   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'min_tilt'", NULL);
03186 #endif
03187   {
03188    float tolua_ret = (float)  self->min_tilt();
03189    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03190   }
03191  }
03192  return 1;
03193 #ifndef TOLUA_RELEASE
03194  tolua_lerror:
03195  tolua_error(tolua_S,"#ferror in function 'min_tilt'.",&tolua_err);
03196  return 0;
03197 #endif
03198 }
03199 #endif //#ifndef TOLUA_DISABLE
03200 
03201 /* method: set_min_tilt of class  fawkes::PanTiltInterface */
03202 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_min_tilt00
03203 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_min_tilt00(lua_State* tolua_S)
03204 {
03205 #ifndef TOLUA_RELEASE
03206  tolua_Error tolua_err;
03207  if (
03208      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03209      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03210      !tolua_isnoobj(tolua_S,3,&tolua_err)
03211  )
03212   goto tolua_lerror;
03213  else
03214 #endif
03215  {
03216   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03217   const float new_min_tilt = ((const float)  tolua_tonumber(tolua_S,2,0));
03218 #ifndef TOLUA_RELEASE
03219   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_min_tilt'", NULL);
03220 #endif
03221   {
03222    self->set_min_tilt(new_min_tilt);
03223   }
03224  }
03225  return 0;
03226 #ifndef TOLUA_RELEASE
03227  tolua_lerror:
03228  tolua_error(tolua_S,"#ferror in function 'set_min_tilt'.",&tolua_err);
03229  return 0;
03230 #endif
03231 }
03232 #endif //#ifndef TOLUA_DISABLE
03233 
03234 /* method: maxlenof_min_tilt of class  fawkes::PanTiltInterface */
03235 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_min_tilt00
03236 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_min_tilt00(lua_State* tolua_S)
03237 {
03238 #ifndef TOLUA_RELEASE
03239  tolua_Error tolua_err;
03240  if (
03241      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03242      !tolua_isnoobj(tolua_S,2,&tolua_err)
03243  )
03244   goto tolua_lerror;
03245  else
03246 #endif
03247  {
03248   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03249 #ifndef TOLUA_RELEASE
03250   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_min_tilt'", NULL);
03251 #endif
03252   {
03253    int tolua_ret = (int)  self->maxlenof_min_tilt();
03254    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03255   }
03256  }
03257  return 1;
03258 #ifndef TOLUA_RELEASE
03259  tolua_lerror:
03260  tolua_error(tolua_S,"#ferror in function 'maxlenof_min_tilt'.",&tolua_err);
03261  return 0;
03262 #endif
03263 }
03264 #endif //#ifndef TOLUA_DISABLE
03265 
03266 /* method: max_tilt of class  fawkes::PanTiltInterface */
03267 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_tilt00
03268 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_tilt00(lua_State* tolua_S)
03269 {
03270 #ifndef TOLUA_RELEASE
03271  tolua_Error tolua_err;
03272  if (
03273      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03274      !tolua_isnoobj(tolua_S,2,&tolua_err)
03275  )
03276   goto tolua_lerror;
03277  else
03278 #endif
03279  {
03280   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03281 #ifndef TOLUA_RELEASE
03282   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_tilt'", NULL);
03283 #endif
03284   {
03285    float tolua_ret = (float)  self->max_tilt();
03286    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03287   }
03288  }
03289  return 1;
03290 #ifndef TOLUA_RELEASE
03291  tolua_lerror:
03292  tolua_error(tolua_S,"#ferror in function 'max_tilt'.",&tolua_err);
03293  return 0;
03294 #endif
03295 }
03296 #endif //#ifndef TOLUA_DISABLE
03297 
03298 /* method: set_max_tilt of class  fawkes::PanTiltInterface */
03299 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_tilt00
03300 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_tilt00(lua_State* tolua_S)
03301 {
03302 #ifndef TOLUA_RELEASE
03303  tolua_Error tolua_err;
03304  if (
03305      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03306      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03307      !tolua_isnoobj(tolua_S,3,&tolua_err)
03308  )
03309   goto tolua_lerror;
03310  else
03311 #endif
03312  {
03313   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03314   const float new_max_tilt = ((const float)  tolua_tonumber(tolua_S,2,0));
03315 #ifndef TOLUA_RELEASE
03316   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_tilt'", NULL);
03317 #endif
03318   {
03319    self->set_max_tilt(new_max_tilt);
03320   }
03321  }
03322  return 0;
03323 #ifndef TOLUA_RELEASE
03324  tolua_lerror:
03325  tolua_error(tolua_S,"#ferror in function 'set_max_tilt'.",&tolua_err);
03326  return 0;
03327 #endif
03328 }
03329 #endif //#ifndef TOLUA_DISABLE
03330 
03331 /* method: maxlenof_max_tilt of class  fawkes::PanTiltInterface */
03332 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_tilt00
03333 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_tilt00(lua_State* tolua_S)
03334 {
03335 #ifndef TOLUA_RELEASE
03336  tolua_Error tolua_err;
03337  if (
03338      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03339      !tolua_isnoobj(tolua_S,2,&tolua_err)
03340  )
03341   goto tolua_lerror;
03342  else
03343 #endif
03344  {
03345   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03346 #ifndef TOLUA_RELEASE
03347   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_tilt'", NULL);
03348 #endif
03349   {
03350    int tolua_ret = (int)  self->maxlenof_max_tilt();
03351    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03352   }
03353  }
03354  return 1;
03355 #ifndef TOLUA_RELEASE
03356  tolua_lerror:
03357  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_tilt'.",&tolua_err);
03358  return 0;
03359 #endif
03360 }
03361 #endif //#ifndef TOLUA_DISABLE
03362 
03363 /* method: max_pan_velocity of class  fawkes::PanTiltInterface */
03364 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_pan_velocity00
03365 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_pan_velocity00(lua_State* tolua_S)
03366 {
03367 #ifndef TOLUA_RELEASE
03368  tolua_Error tolua_err;
03369  if (
03370      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03371      !tolua_isnoobj(tolua_S,2,&tolua_err)
03372  )
03373   goto tolua_lerror;
03374  else
03375 #endif
03376  {
03377   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03378 #ifndef TOLUA_RELEASE
03379   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_pan_velocity'", NULL);
03380 #endif
03381   {
03382    float tolua_ret = (float)  self->max_pan_velocity();
03383    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03384   }
03385  }
03386  return 1;
03387 #ifndef TOLUA_RELEASE
03388  tolua_lerror:
03389  tolua_error(tolua_S,"#ferror in function 'max_pan_velocity'.",&tolua_err);
03390  return 0;
03391 #endif
03392 }
03393 #endif //#ifndef TOLUA_DISABLE
03394 
03395 /* method: set_max_pan_velocity of class  fawkes::PanTiltInterface */
03396 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_pan_velocity00
03397 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_pan_velocity00(lua_State* tolua_S)
03398 {
03399 #ifndef TOLUA_RELEASE
03400  tolua_Error tolua_err;
03401  if (
03402      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03403      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03404      !tolua_isnoobj(tolua_S,3,&tolua_err)
03405  )
03406   goto tolua_lerror;
03407  else
03408 #endif
03409  {
03410   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03411   const float new_max_pan_velocity = ((const float)  tolua_tonumber(tolua_S,2,0));
03412 #ifndef TOLUA_RELEASE
03413   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_pan_velocity'", NULL);
03414 #endif
03415   {
03416    self->set_max_pan_velocity(new_max_pan_velocity);
03417   }
03418  }
03419  return 0;
03420 #ifndef TOLUA_RELEASE
03421  tolua_lerror:
03422  tolua_error(tolua_S,"#ferror in function 'set_max_pan_velocity'.",&tolua_err);
03423  return 0;
03424 #endif
03425 }
03426 #endif //#ifndef TOLUA_DISABLE
03427 
03428 /* method: maxlenof_max_pan_velocity of class  fawkes::PanTiltInterface */
03429 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_pan_velocity00
03430 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_pan_velocity00(lua_State* tolua_S)
03431 {
03432 #ifndef TOLUA_RELEASE
03433  tolua_Error tolua_err;
03434  if (
03435      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03436      !tolua_isnoobj(tolua_S,2,&tolua_err)
03437  )
03438   goto tolua_lerror;
03439  else
03440 #endif
03441  {
03442   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03443 #ifndef TOLUA_RELEASE
03444   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_pan_velocity'", NULL);
03445 #endif
03446   {
03447    int tolua_ret = (int)  self->maxlenof_max_pan_velocity();
03448    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03449   }
03450  }
03451  return 1;
03452 #ifndef TOLUA_RELEASE
03453  tolua_lerror:
03454  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_pan_velocity'.",&tolua_err);
03455  return 0;
03456 #endif
03457 }
03458 #endif //#ifndef TOLUA_DISABLE
03459 
03460 /* method: max_tilt_velocity of class  fawkes::PanTiltInterface */
03461 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_tilt_velocity00
03462 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_tilt_velocity00(lua_State* tolua_S)
03463 {
03464 #ifndef TOLUA_RELEASE
03465  tolua_Error tolua_err;
03466  if (
03467      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03468      !tolua_isnoobj(tolua_S,2,&tolua_err)
03469  )
03470   goto tolua_lerror;
03471  else
03472 #endif
03473  {
03474   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03475 #ifndef TOLUA_RELEASE
03476   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'max_tilt_velocity'", NULL);
03477 #endif
03478   {
03479    float tolua_ret = (float)  self->max_tilt_velocity();
03480    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03481   }
03482  }
03483  return 1;
03484 #ifndef TOLUA_RELEASE
03485  tolua_lerror:
03486  tolua_error(tolua_S,"#ferror in function 'max_tilt_velocity'.",&tolua_err);
03487  return 0;
03488 #endif
03489 }
03490 #endif //#ifndef TOLUA_DISABLE
03491 
03492 /* method: set_max_tilt_velocity of class  fawkes::PanTiltInterface */
03493 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_tilt_velocity00
03494 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_tilt_velocity00(lua_State* tolua_S)
03495 {
03496 #ifndef TOLUA_RELEASE
03497  tolua_Error tolua_err;
03498  if (
03499      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03500      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03501      !tolua_isnoobj(tolua_S,3,&tolua_err)
03502  )
03503   goto tolua_lerror;
03504  else
03505 #endif
03506  {
03507   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03508   const float new_max_tilt_velocity = ((const float)  tolua_tonumber(tolua_S,2,0));
03509 #ifndef TOLUA_RELEASE
03510   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_max_tilt_velocity'", NULL);
03511 #endif
03512   {
03513    self->set_max_tilt_velocity(new_max_tilt_velocity);
03514   }
03515  }
03516  return 0;
03517 #ifndef TOLUA_RELEASE
03518  tolua_lerror:
03519  tolua_error(tolua_S,"#ferror in function 'set_max_tilt_velocity'.",&tolua_err);
03520  return 0;
03521 #endif
03522 }
03523 #endif //#ifndef TOLUA_DISABLE
03524 
03525 /* method: maxlenof_max_tilt_velocity of class  fawkes::PanTiltInterface */
03526 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_tilt_velocity00
03527 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_tilt_velocity00(lua_State* tolua_S)
03528 {
03529 #ifndef TOLUA_RELEASE
03530  tolua_Error tolua_err;
03531  if (
03532      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03533      !tolua_isnoobj(tolua_S,2,&tolua_err)
03534  )
03535   goto tolua_lerror;
03536  else
03537 #endif
03538  {
03539   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03540 #ifndef TOLUA_RELEASE
03541   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_max_tilt_velocity'", NULL);
03542 #endif
03543   {
03544    int tolua_ret = (int)  self->maxlenof_max_tilt_velocity();
03545    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03546   }
03547  }
03548  return 1;
03549 #ifndef TOLUA_RELEASE
03550  tolua_lerror:
03551  tolua_error(tolua_S,"#ferror in function 'maxlenof_max_tilt_velocity'.",&tolua_err);
03552  return 0;
03553 #endif
03554 }
03555 #endif //#ifndef TOLUA_DISABLE
03556 
03557 /* method: pan_velocity of class  fawkes::PanTiltInterface */
03558 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_pan_velocity00
03559 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_pan_velocity00(lua_State* tolua_S)
03560 {
03561 #ifndef TOLUA_RELEASE
03562  tolua_Error tolua_err;
03563  if (
03564      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03565      !tolua_isnoobj(tolua_S,2,&tolua_err)
03566  )
03567   goto tolua_lerror;
03568  else
03569 #endif
03570  {
03571   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03572 #ifndef TOLUA_RELEASE
03573   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pan_velocity'", NULL);
03574 #endif
03575   {
03576    float tolua_ret = (float)  self->pan_velocity();
03577    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03578   }
03579  }
03580  return 1;
03581 #ifndef TOLUA_RELEASE
03582  tolua_lerror:
03583  tolua_error(tolua_S,"#ferror in function 'pan_velocity'.",&tolua_err);
03584  return 0;
03585 #endif
03586 }
03587 #endif //#ifndef TOLUA_DISABLE
03588 
03589 /* method: set_pan_velocity of class  fawkes::PanTiltInterface */
03590 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_pan_velocity00
03591 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_pan_velocity00(lua_State* tolua_S)
03592 {
03593 #ifndef TOLUA_RELEASE
03594  tolua_Error tolua_err;
03595  if (
03596      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03597      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03598      !tolua_isnoobj(tolua_S,3,&tolua_err)
03599  )
03600   goto tolua_lerror;
03601  else
03602 #endif
03603  {
03604   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03605   const float new_pan_velocity = ((const float)  tolua_tonumber(tolua_S,2,0));
03606 #ifndef TOLUA_RELEASE
03607   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_pan_velocity'", NULL);
03608 #endif
03609   {
03610    self->set_pan_velocity(new_pan_velocity);
03611   }
03612  }
03613  return 0;
03614 #ifndef TOLUA_RELEASE
03615  tolua_lerror:
03616  tolua_error(tolua_S,"#ferror in function 'set_pan_velocity'.",&tolua_err);
03617  return 0;
03618 #endif
03619 }
03620 #endif //#ifndef TOLUA_DISABLE
03621 
03622 /* method: maxlenof_pan_velocity of class  fawkes::PanTiltInterface */
03623 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_pan_velocity00
03624 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_pan_velocity00(lua_State* tolua_S)
03625 {
03626 #ifndef TOLUA_RELEASE
03627  tolua_Error tolua_err;
03628  if (
03629      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03630      !tolua_isnoobj(tolua_S,2,&tolua_err)
03631  )
03632   goto tolua_lerror;
03633  else
03634 #endif
03635  {
03636   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03637 #ifndef TOLUA_RELEASE
03638   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_pan_velocity'", NULL);
03639 #endif
03640   {
03641    int tolua_ret = (int)  self->maxlenof_pan_velocity();
03642    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03643   }
03644  }
03645  return 1;
03646 #ifndef TOLUA_RELEASE
03647  tolua_lerror:
03648  tolua_error(tolua_S,"#ferror in function 'maxlenof_pan_velocity'.",&tolua_err);
03649  return 0;
03650 #endif
03651 }
03652 #endif //#ifndef TOLUA_DISABLE
03653 
03654 /* method: tilt_velocity of class  fawkes::PanTiltInterface */
03655 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_tilt_velocity00
03656 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_tilt_velocity00(lua_State* tolua_S)
03657 {
03658 #ifndef TOLUA_RELEASE
03659  tolua_Error tolua_err;
03660  if (
03661      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03662      !tolua_isnoobj(tolua_S,2,&tolua_err)
03663  )
03664   goto tolua_lerror;
03665  else
03666 #endif
03667  {
03668   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03669 #ifndef TOLUA_RELEASE
03670   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tilt_velocity'", NULL);
03671 #endif
03672   {
03673    float tolua_ret = (float)  self->tilt_velocity();
03674    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03675   }
03676  }
03677  return 1;
03678 #ifndef TOLUA_RELEASE
03679  tolua_lerror:
03680  tolua_error(tolua_S,"#ferror in function 'tilt_velocity'.",&tolua_err);
03681  return 0;
03682 #endif
03683 }
03684 #endif //#ifndef TOLUA_DISABLE
03685 
03686 /* method: set_tilt_velocity of class  fawkes::PanTiltInterface */
03687 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_tilt_velocity00
03688 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_tilt_velocity00(lua_State* tolua_S)
03689 {
03690 #ifndef TOLUA_RELEASE
03691  tolua_Error tolua_err;
03692  if (
03693      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03694      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03695      !tolua_isnoobj(tolua_S,3,&tolua_err)
03696  )
03697   goto tolua_lerror;
03698  else
03699 #endif
03700  {
03701   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03702   const float new_tilt_velocity = ((const float)  tolua_tonumber(tolua_S,2,0));
03703 #ifndef TOLUA_RELEASE
03704   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_tilt_velocity'", NULL);
03705 #endif
03706   {
03707    self->set_tilt_velocity(new_tilt_velocity);
03708   }
03709  }
03710  return 0;
03711 #ifndef TOLUA_RELEASE
03712  tolua_lerror:
03713  tolua_error(tolua_S,"#ferror in function 'set_tilt_velocity'.",&tolua_err);
03714  return 0;
03715 #endif
03716 }
03717 #endif //#ifndef TOLUA_DISABLE
03718 
03719 /* method: maxlenof_tilt_velocity of class  fawkes::PanTiltInterface */
03720 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_tilt_velocity00
03721 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_tilt_velocity00(lua_State* tolua_S)
03722 {
03723 #ifndef TOLUA_RELEASE
03724  tolua_Error tolua_err;
03725  if (
03726      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03727      !tolua_isnoobj(tolua_S,2,&tolua_err)
03728  )
03729   goto tolua_lerror;
03730  else
03731 #endif
03732  {
03733   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03734 #ifndef TOLUA_RELEASE
03735   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_tilt_velocity'", NULL);
03736 #endif
03737   {
03738    int tolua_ret = (int)  self->maxlenof_tilt_velocity();
03739    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03740   }
03741  }
03742  return 1;
03743 #ifndef TOLUA_RELEASE
03744  tolua_lerror:
03745  tolua_error(tolua_S,"#ferror in function 'maxlenof_tilt_velocity'.",&tolua_err);
03746  return 0;
03747 #endif
03748 }
03749 #endif //#ifndef TOLUA_DISABLE
03750 
03751 /* method: pan_margin of class  fawkes::PanTiltInterface */
03752 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_pan_margin00
03753 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_pan_margin00(lua_State* tolua_S)
03754 {
03755 #ifndef TOLUA_RELEASE
03756  tolua_Error tolua_err;
03757  if (
03758      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03759      !tolua_isnoobj(tolua_S,2,&tolua_err)
03760  )
03761   goto tolua_lerror;
03762  else
03763 #endif
03764  {
03765   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03766 #ifndef TOLUA_RELEASE
03767   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pan_margin'", NULL);
03768 #endif
03769   {
03770    float tolua_ret = (float)  self->pan_margin();
03771    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03772   }
03773  }
03774  return 1;
03775 #ifndef TOLUA_RELEASE
03776  tolua_lerror:
03777  tolua_error(tolua_S,"#ferror in function 'pan_margin'.",&tolua_err);
03778  return 0;
03779 #endif
03780 }
03781 #endif //#ifndef TOLUA_DISABLE
03782 
03783 /* method: set_pan_margin of class  fawkes::PanTiltInterface */
03784 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_pan_margin00
03785 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_pan_margin00(lua_State* tolua_S)
03786 {
03787 #ifndef TOLUA_RELEASE
03788  tolua_Error tolua_err;
03789  if (
03790      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03791      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03792      !tolua_isnoobj(tolua_S,3,&tolua_err)
03793  )
03794   goto tolua_lerror;
03795  else
03796 #endif
03797  {
03798   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03799   const float new_pan_margin = ((const float)  tolua_tonumber(tolua_S,2,0));
03800 #ifndef TOLUA_RELEASE
03801   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_pan_margin'", NULL);
03802 #endif
03803   {
03804    self->set_pan_margin(new_pan_margin);
03805   }
03806  }
03807  return 0;
03808 #ifndef TOLUA_RELEASE
03809  tolua_lerror:
03810  tolua_error(tolua_S,"#ferror in function 'set_pan_margin'.",&tolua_err);
03811  return 0;
03812 #endif
03813 }
03814 #endif //#ifndef TOLUA_DISABLE
03815 
03816 /* method: maxlenof_pan_margin of class  fawkes::PanTiltInterface */
03817 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_pan_margin00
03818 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_pan_margin00(lua_State* tolua_S)
03819 {
03820 #ifndef TOLUA_RELEASE
03821  tolua_Error tolua_err;
03822  if (
03823      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03824      !tolua_isnoobj(tolua_S,2,&tolua_err)
03825  )
03826   goto tolua_lerror;
03827  else
03828 #endif
03829  {
03830   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03831 #ifndef TOLUA_RELEASE
03832   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_pan_margin'", NULL);
03833 #endif
03834   {
03835    int tolua_ret = (int)  self->maxlenof_pan_margin();
03836    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03837   }
03838  }
03839  return 1;
03840 #ifndef TOLUA_RELEASE
03841  tolua_lerror:
03842  tolua_error(tolua_S,"#ferror in function 'maxlenof_pan_margin'.",&tolua_err);
03843  return 0;
03844 #endif
03845 }
03846 #endif //#ifndef TOLUA_DISABLE
03847 
03848 /* method: tilt_margin of class  fawkes::PanTiltInterface */
03849 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_tilt_margin00
03850 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_tilt_margin00(lua_State* tolua_S)
03851 {
03852 #ifndef TOLUA_RELEASE
03853  tolua_Error tolua_err;
03854  if (
03855      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03856      !tolua_isnoobj(tolua_S,2,&tolua_err)
03857  )
03858   goto tolua_lerror;
03859  else
03860 #endif
03861  {
03862   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03863 #ifndef TOLUA_RELEASE
03864   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tilt_margin'", NULL);
03865 #endif
03866   {
03867    float tolua_ret = (float)  self->tilt_margin();
03868    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03869   }
03870  }
03871  return 1;
03872 #ifndef TOLUA_RELEASE
03873  tolua_lerror:
03874  tolua_error(tolua_S,"#ferror in function 'tilt_margin'.",&tolua_err);
03875  return 0;
03876 #endif
03877 }
03878 #endif //#ifndef TOLUA_DISABLE
03879 
03880 /* method: set_tilt_margin of class  fawkes::PanTiltInterface */
03881 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_tilt_margin00
03882 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_tilt_margin00(lua_State* tolua_S)
03883 {
03884 #ifndef TOLUA_RELEASE
03885  tolua_Error tolua_err;
03886  if (
03887      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
03888      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
03889      !tolua_isnoobj(tolua_S,3,&tolua_err)
03890  )
03891   goto tolua_lerror;
03892  else
03893 #endif
03894  {
03895   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03896   const float new_tilt_margin = ((const float)  tolua_tonumber(tolua_S,2,0));
03897 #ifndef TOLUA_RELEASE
03898   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_tilt_margin'", NULL);
03899 #endif
03900   {
03901    self->set_tilt_margin(new_tilt_margin);
03902   }
03903  }
03904  return 0;
03905 #ifndef TOLUA_RELEASE
03906  tolua_lerror:
03907  tolua_error(tolua_S,"#ferror in function 'set_tilt_margin'.",&tolua_err);
03908  return 0;
03909 #endif
03910 }
03911 #endif //#ifndef TOLUA_DISABLE
03912 
03913 /* method: maxlenof_tilt_margin of class  fawkes::PanTiltInterface */
03914 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_tilt_margin00
03915 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_tilt_margin00(lua_State* tolua_S)
03916 {
03917 #ifndef TOLUA_RELEASE
03918  tolua_Error tolua_err;
03919  if (
03920      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03921      !tolua_isnoobj(tolua_S,2,&tolua_err)
03922  )
03923   goto tolua_lerror;
03924  else
03925 #endif
03926  {
03927   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03928 #ifndef TOLUA_RELEASE
03929   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_tilt_margin'", NULL);
03930 #endif
03931   {
03932    int tolua_ret = (int)  self->maxlenof_tilt_margin();
03933    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
03934   }
03935  }
03936  return 1;
03937 #ifndef TOLUA_RELEASE
03938  tolua_lerror:
03939  tolua_error(tolua_S,"#ferror in function 'maxlenof_tilt_margin'.",&tolua_err);
03940  return 0;
03941 #endif
03942 }
03943 #endif //#ifndef TOLUA_DISABLE
03944 
03945 /* method: oftype of class  fawkes::PanTiltInterface */
03946 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_oftype00
03947 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_oftype00(lua_State* tolua_S)
03948 {
03949 #ifndef TOLUA_RELEASE
03950  tolua_Error tolua_err;
03951  if (
03952      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03953      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
03954      !tolua_isnoobj(tolua_S,3,&tolua_err)
03955  )
03956   goto tolua_lerror;
03957  else
03958 #endif
03959  {
03960   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03961   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
03962 #ifndef TOLUA_RELEASE
03963   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
03964 #endif
03965   {
03966    bool tolua_ret = (bool)  self->oftype(interface_type);
03967    tolua_pushboolean(tolua_S,(bool)tolua_ret);
03968   }
03969  }
03970  return 1;
03971 #ifndef TOLUA_RELEASE
03972  tolua_lerror:
03973  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
03974  return 0;
03975 #endif
03976 }
03977 #endif //#ifndef TOLUA_DISABLE
03978 
03979 /* method: datachunk of class  fawkes::PanTiltInterface */
03980 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_datachunk00
03981 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_datachunk00(lua_State* tolua_S)
03982 {
03983 #ifndef TOLUA_RELEASE
03984  tolua_Error tolua_err;
03985  if (
03986      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
03987      !tolua_isnoobj(tolua_S,2,&tolua_err)
03988  )
03989   goto tolua_lerror;
03990  else
03991 #endif
03992  {
03993   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
03994 #ifndef TOLUA_RELEASE
03995   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
03996 #endif
03997   {
03998    const void* tolua_ret = (const void*)  self->datachunk();
03999    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
04000   }
04001  }
04002  return 1;
04003 #ifndef TOLUA_RELEASE
04004  tolua_lerror:
04005  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
04006  return 0;
04007 #endif
04008 }
04009 #endif //#ifndef TOLUA_DISABLE
04010 
04011 /* method: datasize of class  fawkes::PanTiltInterface */
04012 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_datasize00
04013 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_datasize00(lua_State* tolua_S)
04014 {
04015 #ifndef TOLUA_RELEASE
04016  tolua_Error tolua_err;
04017  if (
04018      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04019      !tolua_isnoobj(tolua_S,2,&tolua_err)
04020  )
04021   goto tolua_lerror;
04022  else
04023 #endif
04024  {
04025   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04026 #ifndef TOLUA_RELEASE
04027   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
04028 #endif
04029   {
04030    unsigned int tolua_ret = (unsigned int)  self->datasize();
04031    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04032   }
04033  }
04034  return 1;
04035 #ifndef TOLUA_RELEASE
04036  tolua_lerror:
04037  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
04038  return 0;
04039 #endif
04040 }
04041 #endif //#ifndef TOLUA_DISABLE
04042 
04043 /* method: type of class  fawkes::PanTiltInterface */
04044 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_type00
04045 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_type00(lua_State* tolua_S)
04046 {
04047 #ifndef TOLUA_RELEASE
04048  tolua_Error tolua_err;
04049  if (
04050      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04051      !tolua_isnoobj(tolua_S,2,&tolua_err)
04052  )
04053   goto tolua_lerror;
04054  else
04055 #endif
04056  {
04057   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04058 #ifndef TOLUA_RELEASE
04059   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
04060 #endif
04061   {
04062    const char* tolua_ret = (const char*)  self->type();
04063    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04064   }
04065  }
04066  return 1;
04067 #ifndef TOLUA_RELEASE
04068  tolua_lerror:
04069  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
04070  return 0;
04071 #endif
04072 }
04073 #endif //#ifndef TOLUA_DISABLE
04074 
04075 /* method: id of class  fawkes::PanTiltInterface */
04076 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_id00
04077 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_id00(lua_State* tolua_S)
04078 {
04079 #ifndef TOLUA_RELEASE
04080  tolua_Error tolua_err;
04081  if (
04082      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04083      !tolua_isnoobj(tolua_S,2,&tolua_err)
04084  )
04085   goto tolua_lerror;
04086  else
04087 #endif
04088  {
04089   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04090 #ifndef TOLUA_RELEASE
04091   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
04092 #endif
04093   {
04094    const char* tolua_ret = (const char*)  self->id();
04095    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04096   }
04097  }
04098  return 1;
04099 #ifndef TOLUA_RELEASE
04100  tolua_lerror:
04101  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
04102  return 0;
04103 #endif
04104 }
04105 #endif //#ifndef TOLUA_DISABLE
04106 
04107 /* method: uid of class  fawkes::PanTiltInterface */
04108 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_uid00
04109 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_uid00(lua_State* tolua_S)
04110 {
04111 #ifndef TOLUA_RELEASE
04112  tolua_Error tolua_err;
04113  if (
04114      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04115      !tolua_isnoobj(tolua_S,2,&tolua_err)
04116  )
04117   goto tolua_lerror;
04118  else
04119 #endif
04120  {
04121   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04122 #ifndef TOLUA_RELEASE
04123   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
04124 #endif
04125   {
04126    const char* tolua_ret = (const char*)  self->uid();
04127    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04128   }
04129  }
04130  return 1;
04131 #ifndef TOLUA_RELEASE
04132  tolua_lerror:
04133  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
04134  return 0;
04135 #endif
04136 }
04137 #endif //#ifndef TOLUA_DISABLE
04138 
04139 /* method: serial of class  fawkes::PanTiltInterface */
04140 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_serial00
04141 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_serial00(lua_State* tolua_S)
04142 {
04143 #ifndef TOLUA_RELEASE
04144  tolua_Error tolua_err;
04145  if (
04146      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04147      !tolua_isnoobj(tolua_S,2,&tolua_err)
04148  )
04149   goto tolua_lerror;
04150  else
04151 #endif
04152  {
04153   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04154 #ifndef TOLUA_RELEASE
04155   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
04156 #endif
04157   {
04158    unsigned int tolua_ret = (unsigned int)  self->serial();
04159    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04160   }
04161  }
04162  return 1;
04163 #ifndef TOLUA_RELEASE
04164  tolua_lerror:
04165  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
04166  return 0;
04167 #endif
04168 }
04169 #endif //#ifndef TOLUA_DISABLE
04170 
04171 /* method: mem_serial of class  fawkes::PanTiltInterface */
04172 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_mem_serial00
04173 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_mem_serial00(lua_State* tolua_S)
04174 {
04175 #ifndef TOLUA_RELEASE
04176  tolua_Error tolua_err;
04177  if (
04178      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04179      !tolua_isnoobj(tolua_S,2,&tolua_err)
04180  )
04181   goto tolua_lerror;
04182  else
04183 #endif
04184  {
04185   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04186 #ifndef TOLUA_RELEASE
04187   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
04188 #endif
04189   {
04190    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
04191    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04192   }
04193  }
04194  return 1;
04195 #ifndef TOLUA_RELEASE
04196  tolua_lerror:
04197  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
04198  return 0;
04199 #endif
04200 }
04201 #endif //#ifndef TOLUA_DISABLE
04202 
04203 /* method: operator== of class  fawkes::PanTiltInterface */
04204 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface__eq00
04205 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface__eq00(lua_State* tolua_S)
04206 {
04207 #ifndef TOLUA_RELEASE
04208  tolua_Error tolua_err;
04209  if (
04210      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04211      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
04212      !tolua_isnoobj(tolua_S,3,&tolua_err)
04213  )
04214   goto tolua_lerror;
04215  else
04216 #endif
04217  {
04218   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04219   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
04220 #ifndef TOLUA_RELEASE
04221   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
04222 #endif
04223   {
04224    bool tolua_ret = (bool)  self->operator==(*comp);
04225    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04226   }
04227  }
04228  return 1;
04229 #ifndef TOLUA_RELEASE
04230  tolua_lerror:
04231  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
04232  return 0;
04233 #endif
04234 }
04235 #endif //#ifndef TOLUA_DISABLE
04236 
04237 /* method: hash of class  fawkes::PanTiltInterface */
04238 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_hash00
04239 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_hash00(lua_State* tolua_S)
04240 {
04241 #ifndef TOLUA_RELEASE
04242  tolua_Error tolua_err;
04243  if (
04244      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04245      !tolua_isnoobj(tolua_S,2,&tolua_err)
04246  )
04247   goto tolua_lerror;
04248  else
04249 #endif
04250  {
04251   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04252 #ifndef TOLUA_RELEASE
04253   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
04254 #endif
04255   {
04256    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
04257    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04258   }
04259  }
04260  return 1;
04261 #ifndef TOLUA_RELEASE
04262  tolua_lerror:
04263  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
04264  return 0;
04265 #endif
04266 }
04267 #endif //#ifndef TOLUA_DISABLE
04268 
04269 /* method: hash_size of class  fawkes::PanTiltInterface */
04270 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_hash_size00
04271 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_hash_size00(lua_State* tolua_S)
04272 {
04273 #ifndef TOLUA_RELEASE
04274  tolua_Error tolua_err;
04275  if (
04276      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04277      !tolua_isnoobj(tolua_S,2,&tolua_err)
04278  )
04279   goto tolua_lerror;
04280  else
04281 #endif
04282  {
04283   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04284 #ifndef TOLUA_RELEASE
04285   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
04286 #endif
04287   {
04288    int tolua_ret = (int)  self->hash_size();
04289    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04290   }
04291  }
04292  return 1;
04293 #ifndef TOLUA_RELEASE
04294  tolua_lerror:
04295  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
04296  return 0;
04297 #endif
04298 }
04299 #endif //#ifndef TOLUA_DISABLE
04300 
04301 /* method: hash_printable of class  fawkes::PanTiltInterface */
04302 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_hash_printable00
04303 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_hash_printable00(lua_State* tolua_S)
04304 {
04305 #ifndef TOLUA_RELEASE
04306  tolua_Error tolua_err;
04307  if (
04308      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04309      !tolua_isnoobj(tolua_S,2,&tolua_err)
04310  )
04311   goto tolua_lerror;
04312  else
04313 #endif
04314  {
04315   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04316 #ifndef TOLUA_RELEASE
04317   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
04318 #endif
04319   {
04320    const char* tolua_ret = (const char*)  self->hash_printable();
04321    tolua_pushstring(tolua_S,(const char*)tolua_ret);
04322   }
04323  }
04324  return 1;
04325 #ifndef TOLUA_RELEASE
04326  tolua_lerror:
04327  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
04328  return 0;
04329 #endif
04330 }
04331 #endif //#ifndef TOLUA_DISABLE
04332 
04333 /* method: is_writer of class  fawkes::PanTiltInterface */
04334 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_writer00
04335 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_writer00(lua_State* tolua_S)
04336 {
04337 #ifndef TOLUA_RELEASE
04338  tolua_Error tolua_err;
04339  if (
04340      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04341      !tolua_isnoobj(tolua_S,2,&tolua_err)
04342  )
04343   goto tolua_lerror;
04344  else
04345 #endif
04346  {
04347   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04348 #ifndef TOLUA_RELEASE
04349   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
04350 #endif
04351   {
04352    bool tolua_ret = (bool)  self->is_writer();
04353    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04354   }
04355  }
04356  return 1;
04357 #ifndef TOLUA_RELEASE
04358  tolua_lerror:
04359  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
04360  return 0;
04361 #endif
04362 }
04363 #endif //#ifndef TOLUA_DISABLE
04364 
04365 /* method: set_from_chunk of class  fawkes::PanTiltInterface */
04366 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_from_chunk00
04367 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_from_chunk00(lua_State* tolua_S)
04368 {
04369 #ifndef TOLUA_RELEASE
04370  tolua_Error tolua_err;
04371  if (
04372      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04373      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
04374      !tolua_isnoobj(tolua_S,3,&tolua_err)
04375  )
04376   goto tolua_lerror;
04377  else
04378 #endif
04379  {
04380   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04381   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
04382 #ifndef TOLUA_RELEASE
04383   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
04384 #endif
04385   {
04386    self->set_from_chunk(chunk);
04387   }
04388  }
04389  return 0;
04390 #ifndef TOLUA_RELEASE
04391  tolua_lerror:
04392  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
04393  return 0;
04394 #endif
04395 }
04396 #endif //#ifndef TOLUA_DISABLE
04397 
04398 /* method: create_message of class  fawkes::PanTiltInterface */
04399 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_create_message00
04400 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_create_message00(lua_State* tolua_S)
04401 {
04402 #ifndef TOLUA_RELEASE
04403  tolua_Error tolua_err;
04404  if (
04405      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04406      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
04407      !tolua_isnoobj(tolua_S,3,&tolua_err)
04408  )
04409   goto tolua_lerror;
04410  else
04411 #endif
04412  {
04413   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04414   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
04415 #ifndef TOLUA_RELEASE
04416   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
04417 #endif
04418   {
04419    Message* tolua_ret = (Message*)  self->create_message(type);
04420     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
04421   }
04422  }
04423  return 1;
04424 #ifndef TOLUA_RELEASE
04425  tolua_lerror:
04426  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
04427  return 0;
04428 #endif
04429 }
04430 #endif //#ifndef TOLUA_DISABLE
04431 
04432 /* method: read of class  fawkes::PanTiltInterface */
04433 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_read00
04434 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_read00(lua_State* tolua_S)
04435 {
04436 #ifndef TOLUA_RELEASE
04437  tolua_Error tolua_err;
04438  if (
04439      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04440      !tolua_isnoobj(tolua_S,2,&tolua_err)
04441  )
04442   goto tolua_lerror;
04443  else
04444 #endif
04445  {
04446   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04447 #ifndef TOLUA_RELEASE
04448   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
04449 #endif
04450   {
04451    self->read();
04452   }
04453  }
04454  return 0;
04455 #ifndef TOLUA_RELEASE
04456  tolua_lerror:
04457  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
04458  return 0;
04459 #endif
04460 }
04461 #endif //#ifndef TOLUA_DISABLE
04462 
04463 /* method: write of class  fawkes::PanTiltInterface */
04464 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_write00
04465 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_write00(lua_State* tolua_S)
04466 {
04467 #ifndef TOLUA_RELEASE
04468  tolua_Error tolua_err;
04469  if (
04470      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04471      !tolua_isnoobj(tolua_S,2,&tolua_err)
04472  )
04473   goto tolua_lerror;
04474  else
04475 #endif
04476  {
04477   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04478 #ifndef TOLUA_RELEASE
04479   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
04480 #endif
04481   {
04482    self->write();
04483   }
04484  }
04485  return 0;
04486 #ifndef TOLUA_RELEASE
04487  tolua_lerror:
04488  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
04489  return 0;
04490 #endif
04491 }
04492 #endif //#ifndef TOLUA_DISABLE
04493 
04494 /* method: has_writer of class  fawkes::PanTiltInterface */
04495 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_has_writer00
04496 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_has_writer00(lua_State* tolua_S)
04497 {
04498 #ifndef TOLUA_RELEASE
04499  tolua_Error tolua_err;
04500  if (
04501      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04502      !tolua_isnoobj(tolua_S,2,&tolua_err)
04503  )
04504   goto tolua_lerror;
04505  else
04506 #endif
04507  {
04508   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04509 #ifndef TOLUA_RELEASE
04510   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
04511 #endif
04512   {
04513    bool tolua_ret = (bool)  self->has_writer();
04514    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04515   }
04516  }
04517  return 1;
04518 #ifndef TOLUA_RELEASE
04519  tolua_lerror:
04520  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
04521  return 0;
04522 #endif
04523 }
04524 #endif //#ifndef TOLUA_DISABLE
04525 
04526 /* method: num_readers of class  fawkes::PanTiltInterface */
04527 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_num_readers00
04528 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_num_readers00(lua_State* tolua_S)
04529 {
04530 #ifndef TOLUA_RELEASE
04531  tolua_Error tolua_err;
04532  if (
04533      !tolua_isusertype(tolua_S,1,"const fawkes::PanTiltInterface",0,&tolua_err) ||
04534      !tolua_isnoobj(tolua_S,2,&tolua_err)
04535  )
04536   goto tolua_lerror;
04537  else
04538 #endif
04539  {
04540   const fawkes::PanTiltInterface* self = (const fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04541 #ifndef TOLUA_RELEASE
04542   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
04543 #endif
04544   {
04545    unsigned int tolua_ret = (unsigned int)  self->num_readers();
04546    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04547   }
04548  }
04549  return 1;
04550 #ifndef TOLUA_RELEASE
04551  tolua_lerror:
04552  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
04553  return 0;
04554 #endif
04555 }
04556 #endif //#ifndef TOLUA_DISABLE
04557 
04558 /* method: msgq_enqueue_copy of class  fawkes::PanTiltInterface */
04559 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_enqueue_copy00
04560 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_enqueue_copy00(lua_State* tolua_S)
04561 {
04562 #ifndef TOLUA_RELEASE
04563  tolua_Error tolua_err;
04564  if (
04565      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04566      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
04567      !tolua_isnoobj(tolua_S,3,&tolua_err)
04568  )
04569   goto tolua_lerror;
04570  else
04571 #endif
04572  {
04573   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04574   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
04575 #ifndef TOLUA_RELEASE
04576   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
04577 #endif
04578   {
04579    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
04580    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04581   }
04582  }
04583  return 1;
04584 #ifndef TOLUA_RELEASE
04585  tolua_lerror:
04586  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
04587  return 0;
04588 #endif
04589 }
04590 #endif //#ifndef TOLUA_DISABLE
04591 
04592 /* method: msgq_remove of class  fawkes::PanTiltInterface */
04593 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_remove00
04594 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_remove00(lua_State* tolua_S)
04595 {
04596 #ifndef TOLUA_RELEASE
04597  tolua_Error tolua_err;
04598  if (
04599      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04600      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
04601      !tolua_isnoobj(tolua_S,3,&tolua_err)
04602  )
04603   goto tolua_lerror;
04604  else
04605 #endif
04606  {
04607   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04608   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
04609 #ifndef TOLUA_RELEASE
04610   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
04611 #endif
04612   {
04613    self->msgq_remove(message);
04614   }
04615  }
04616  return 0;
04617 #ifndef TOLUA_RELEASE
04618  tolua_lerror:
04619  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
04620  return 0;
04621 #endif
04622 }
04623 #endif //#ifndef TOLUA_DISABLE
04624 
04625 /* method: msgq_remove of class  fawkes::PanTiltInterface */
04626 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_remove01
04627 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_remove01(lua_State* tolua_S)
04628 {
04629  tolua_Error tolua_err;
04630  if (
04631      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04632      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
04633      !tolua_isnoobj(tolua_S,3,&tolua_err)
04634  )
04635   goto tolua_lerror;
04636  else
04637  {
04638   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04639   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
04640 #ifndef TOLUA_RELEASE
04641   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
04642 #endif
04643   {
04644    self->msgq_remove(message_id);
04645   }
04646  }
04647  return 0;
04648 tolua_lerror:
04649  return tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_remove00(tolua_S);
04650 }
04651 #endif //#ifndef TOLUA_DISABLE
04652 
04653 /* method: msgq_size of class  fawkes::PanTiltInterface */
04654 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_size00
04655 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_size00(lua_State* tolua_S)
04656 {
04657 #ifndef TOLUA_RELEASE
04658  tolua_Error tolua_err;
04659  if (
04660      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04661      !tolua_isnoobj(tolua_S,2,&tolua_err)
04662  )
04663   goto tolua_lerror;
04664  else
04665 #endif
04666  {
04667   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04668 #ifndef TOLUA_RELEASE
04669   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
04670 #endif
04671   {
04672    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
04673    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
04674   }
04675  }
04676  return 1;
04677 #ifndef TOLUA_RELEASE
04678  tolua_lerror:
04679  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
04680  return 0;
04681 #endif
04682 }
04683 #endif //#ifndef TOLUA_DISABLE
04684 
04685 /* method: msgq_flush of class  fawkes::PanTiltInterface */
04686 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_flush00
04687 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_flush00(lua_State* tolua_S)
04688 {
04689 #ifndef TOLUA_RELEASE
04690  tolua_Error tolua_err;
04691  if (
04692      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04693      !tolua_isnoobj(tolua_S,2,&tolua_err)
04694  )
04695   goto tolua_lerror;
04696  else
04697 #endif
04698  {
04699   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04700 #ifndef TOLUA_RELEASE
04701   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
04702 #endif
04703   {
04704    self->msgq_flush();
04705   }
04706  }
04707  return 0;
04708 #ifndef TOLUA_RELEASE
04709  tolua_lerror:
04710  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
04711  return 0;
04712 #endif
04713 }
04714 #endif //#ifndef TOLUA_DISABLE
04715 
04716 /* method: msgq_lock of class  fawkes::PanTiltInterface */
04717 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_lock00
04718 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_lock00(lua_State* tolua_S)
04719 {
04720 #ifndef TOLUA_RELEASE
04721  tolua_Error tolua_err;
04722  if (
04723      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04724      !tolua_isnoobj(tolua_S,2,&tolua_err)
04725  )
04726   goto tolua_lerror;
04727  else
04728 #endif
04729  {
04730   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04731 #ifndef TOLUA_RELEASE
04732   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
04733 #endif
04734   {
04735    self->msgq_lock();
04736   }
04737  }
04738  return 0;
04739 #ifndef TOLUA_RELEASE
04740  tolua_lerror:
04741  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
04742  return 0;
04743 #endif
04744 }
04745 #endif //#ifndef TOLUA_DISABLE
04746 
04747 /* method: msgq_try_lock of class  fawkes::PanTiltInterface */
04748 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_try_lock00
04749 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_try_lock00(lua_State* tolua_S)
04750 {
04751 #ifndef TOLUA_RELEASE
04752  tolua_Error tolua_err;
04753  if (
04754      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04755      !tolua_isnoobj(tolua_S,2,&tolua_err)
04756  )
04757   goto tolua_lerror;
04758  else
04759 #endif
04760  {
04761   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04762 #ifndef TOLUA_RELEASE
04763   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
04764 #endif
04765   {
04766    bool tolua_ret = (bool)  self->msgq_try_lock();
04767    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04768   }
04769  }
04770  return 1;
04771 #ifndef TOLUA_RELEASE
04772  tolua_lerror:
04773  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
04774  return 0;
04775 #endif
04776 }
04777 #endif //#ifndef TOLUA_DISABLE
04778 
04779 /* method: msgq_unlock of class  fawkes::PanTiltInterface */
04780 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_unlock00
04781 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_unlock00(lua_State* tolua_S)
04782 {
04783 #ifndef TOLUA_RELEASE
04784  tolua_Error tolua_err;
04785  if (
04786      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04787      !tolua_isnoobj(tolua_S,2,&tolua_err)
04788  )
04789   goto tolua_lerror;
04790  else
04791 #endif
04792  {
04793   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04794 #ifndef TOLUA_RELEASE
04795   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
04796 #endif
04797   {
04798    self->msgq_unlock();
04799   }
04800  }
04801  return 0;
04802 #ifndef TOLUA_RELEASE
04803  tolua_lerror:
04804  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
04805  return 0;
04806 #endif
04807 }
04808 #endif //#ifndef TOLUA_DISABLE
04809 
04810 /* method: msgq_pop of class  fawkes::PanTiltInterface */
04811 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_pop00
04812 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_pop00(lua_State* tolua_S)
04813 {
04814 #ifndef TOLUA_RELEASE
04815  tolua_Error tolua_err;
04816  if (
04817      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04818      !tolua_isnoobj(tolua_S,2,&tolua_err)
04819  )
04820   goto tolua_lerror;
04821  else
04822 #endif
04823  {
04824   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04825 #ifndef TOLUA_RELEASE
04826   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
04827 #endif
04828   {
04829    self->msgq_pop();
04830   }
04831  }
04832  return 0;
04833 #ifndef TOLUA_RELEASE
04834  tolua_lerror:
04835  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
04836  return 0;
04837 #endif
04838 }
04839 #endif //#ifndef TOLUA_DISABLE
04840 
04841 /* method: msgq_first of class  fawkes::PanTiltInterface */
04842 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_first00
04843 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_first00(lua_State* tolua_S)
04844 {
04845 #ifndef TOLUA_RELEASE
04846  tolua_Error tolua_err;
04847  if (
04848      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04849      !tolua_isnoobj(tolua_S,2,&tolua_err)
04850  )
04851   goto tolua_lerror;
04852  else
04853 #endif
04854  {
04855   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04856 #ifndef TOLUA_RELEASE
04857   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
04858 #endif
04859   {
04860    Message* tolua_ret = (Message*)  self->msgq_first();
04861     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
04862   }
04863  }
04864  return 1;
04865 #ifndef TOLUA_RELEASE
04866  tolua_lerror:
04867  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
04868  return 0;
04869 #endif
04870 }
04871 #endif //#ifndef TOLUA_DISABLE
04872 
04873 /* method: msgq_empty of class  fawkes::PanTiltInterface */
04874 #ifndef TOLUA_DISABLE_tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_empty00
04875 static int tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_empty00(lua_State* tolua_S)
04876 {
04877 #ifndef TOLUA_RELEASE
04878  tolua_Error tolua_err;
04879  if (
04880      !tolua_isusertype(tolua_S,1,"fawkes::PanTiltInterface",0,&tolua_err) ||
04881      !tolua_isnoobj(tolua_S,2,&tolua_err)
04882  )
04883   goto tolua_lerror;
04884  else
04885 #endif
04886  {
04887   fawkes::PanTiltInterface* self = (fawkes::PanTiltInterface*)  tolua_tousertype(tolua_S,1,0);
04888 #ifndef TOLUA_RELEASE
04889   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
04890 #endif
04891   {
04892    bool tolua_ret = (bool)  self->msgq_empty();
04893    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04894   }
04895  }
04896  return 1;
04897 #ifndef TOLUA_RELEASE
04898  tolua_lerror:
04899  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
04900  return 0;
04901 #endif
04902 }
04903 #endif //#ifndef TOLUA_DISABLE
04904 
04905 /* Open function */
04906 TOLUA_API int tolua_interfaces_PanTiltInterface_open (lua_State* tolua_S)
04907 {
04908  tolua_open(tolua_S);
04909  tolua_reg_types(tolua_S);
04910  tolua_module(tolua_S,NULL,0);
04911  tolua_beginmodule(tolua_S,NULL);
04912   tolua_module(tolua_S,"fawkes",0);
04913   tolua_beginmodule(tolua_S,"fawkes");
04914    tolua_cclass(tolua_S,"PanTiltInterface","fawkes::PanTiltInterface","Interface",NULL);
04915    tolua_beginmodule(tolua_S,"PanTiltInterface");
04916     tolua_variable(tolua_S,"FLAG_SUPPORTS_PAN",tolua_get_fawkes__PanTiltInterface_unsigned_FLAG_SUPPORTS_PAN,NULL);
04917     tolua_variable(tolua_S,"FLAG_SUPPORTS_TILT",tolua_get_fawkes__PanTiltInterface_unsigned_FLAG_SUPPORTS_TILT,NULL);
04918     tolua_variable(tolua_S,"ERROR_NONE",tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_NONE,NULL);
04919     tolua_variable(tolua_S,"ERROR_UNSPECIFIC",tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_UNSPECIFIC,NULL);
04920     tolua_variable(tolua_S,"ERROR_COMMUNICATION",tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_COMMUNICATION,NULL);
04921     tolua_variable(tolua_S,"ERROR_PAN_OUTOFRANGE",tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_PAN_OUTOFRANGE,NULL);
04922     tolua_variable(tolua_S,"ERROR_TILT_OUTOFRANGE",tolua_get_fawkes__PanTiltInterface_unsigned_ERROR_TILT_OUTOFRANGE,NULL);
04923     #ifdef __cplusplus
04924     tolua_cclass(tolua_S,"StopMessage","fawkes::PanTiltInterface::StopMessage","Message",tolua_collect_fawkes__PanTiltInterface__StopMessage);
04925     #else
04926     tolua_cclass(tolua_S,"StopMessage","fawkes::PanTiltInterface::StopMessage","Message",NULL);
04927     #endif
04928     tolua_beginmodule(tolua_S,"StopMessage");
04929      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_new00);
04930      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_new00_local);
04931      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_new00_local);
04932      tolua_function(tolua_S,"delete",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_StopMessage_delete00);
04933     tolua_endmodule(tolua_S);
04934     #ifdef __cplusplus
04935     tolua_cclass(tolua_S,"FlushMessage","fawkes::PanTiltInterface::FlushMessage","Message",tolua_collect_fawkes__PanTiltInterface__FlushMessage);
04936     #else
04937     tolua_cclass(tolua_S,"FlushMessage","fawkes::PanTiltInterface::FlushMessage","Message",NULL);
04938     #endif
04939     tolua_beginmodule(tolua_S,"FlushMessage");
04940      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_new00);
04941      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_new00_local);
04942      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_new00_local);
04943      tolua_function(tolua_S,"delete",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_FlushMessage_delete00);
04944     tolua_endmodule(tolua_S);
04945     #ifdef __cplusplus
04946     tolua_cclass(tolua_S,"CalibrateMessage","fawkes::PanTiltInterface::CalibrateMessage","Message",tolua_collect_fawkes__PanTiltInterface__CalibrateMessage);
04947     #else
04948     tolua_cclass(tolua_S,"CalibrateMessage","fawkes::PanTiltInterface::CalibrateMessage","Message",NULL);
04949     #endif
04950     tolua_beginmodule(tolua_S,"CalibrateMessage");
04951      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_new00);
04952      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_new00_local);
04953      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_new00_local);
04954      tolua_function(tolua_S,"delete",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_CalibrateMessage_delete00);
04955     tolua_endmodule(tolua_S);
04956     #ifdef __cplusplus
04957     tolua_cclass(tolua_S,"ParkMessage","fawkes::PanTiltInterface::ParkMessage","Message",tolua_collect_fawkes__PanTiltInterface__ParkMessage);
04958     #else
04959     tolua_cclass(tolua_S,"ParkMessage","fawkes::PanTiltInterface::ParkMessage","Message",NULL);
04960     #endif
04961     tolua_beginmodule(tolua_S,"ParkMessage");
04962      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_new00);
04963      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_new00_local);
04964      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_new00_local);
04965      tolua_function(tolua_S,"delete",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_ParkMessage_delete00);
04966     tolua_endmodule(tolua_S);
04967     #ifdef __cplusplus
04968     tolua_cclass(tolua_S,"GotoMessage","fawkes::PanTiltInterface::GotoMessage","Message",tolua_collect_fawkes__PanTiltInterface__GotoMessage);
04969     #else
04970     tolua_cclass(tolua_S,"GotoMessage","fawkes::PanTiltInterface::GotoMessage","Message",NULL);
04971     #endif
04972     tolua_beginmodule(tolua_S,"GotoMessage");
04973      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new00);
04974      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new00_local);
04975      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new00_local);
04976      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new01);
04977      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new01_local);
04978      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_new01_local);
04979      tolua_function(tolua_S,"delete",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_delete00);
04980      tolua_function(tolua_S,"pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_pan00);
04981      tolua_function(tolua_S,"set_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_set_pan00);
04982      tolua_function(tolua_S,"maxlenof_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_maxlenof_pan00);
04983      tolua_function(tolua_S,"tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_tilt00);
04984      tolua_function(tolua_S,"set_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_set_tilt00);
04985      tolua_function(tolua_S,"maxlenof_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_GotoMessage_maxlenof_tilt00);
04986     tolua_endmodule(tolua_S);
04987     #ifdef __cplusplus
04988     tolua_cclass(tolua_S,"TimedGotoMessage","fawkes::PanTiltInterface::TimedGotoMessage","Message",tolua_collect_fawkes__PanTiltInterface__TimedGotoMessage);
04989     #else
04990     tolua_cclass(tolua_S,"TimedGotoMessage","fawkes::PanTiltInterface::TimedGotoMessage","Message",NULL);
04991     #endif
04992     tolua_beginmodule(tolua_S,"TimedGotoMessage");
04993      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new00);
04994      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new00_local);
04995      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new00_local);
04996      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new01);
04997      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new01_local);
04998      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_new01_local);
04999      tolua_function(tolua_S,"delete",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_delete00);
05000      tolua_function(tolua_S,"time_sec",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_time_sec00);
05001      tolua_function(tolua_S,"set_time_sec",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_set_time_sec00);
05002      tolua_function(tolua_S,"maxlenof_time_sec",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_maxlenof_time_sec00);
05003      tolua_function(tolua_S,"pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_pan00);
05004      tolua_function(tolua_S,"set_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_set_pan00);
05005      tolua_function(tolua_S,"maxlenof_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_maxlenof_pan00);
05006      tolua_function(tolua_S,"tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_tilt00);
05007      tolua_function(tolua_S,"set_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_set_tilt00);
05008      tolua_function(tolua_S,"maxlenof_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_TimedGotoMessage_maxlenof_tilt00);
05009     tolua_endmodule(tolua_S);
05010     #ifdef __cplusplus
05011     tolua_cclass(tolua_S,"SetEnabledMessage","fawkes::PanTiltInterface::SetEnabledMessage","Message",tolua_collect_fawkes__PanTiltInterface__SetEnabledMessage);
05012     #else
05013     tolua_cclass(tolua_S,"SetEnabledMessage","fawkes::PanTiltInterface::SetEnabledMessage","Message",NULL);
05014     #endif
05015     tolua_beginmodule(tolua_S,"SetEnabledMessage");
05016      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new00);
05017      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new00_local);
05018      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new00_local);
05019      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new01);
05020      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new01_local);
05021      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_new01_local);
05022      tolua_function(tolua_S,"delete",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_delete00);
05023      tolua_function(tolua_S,"is_enabled",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_is_enabled00);
05024      tolua_function(tolua_S,"set_enabled",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_set_enabled00);
05025      tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetEnabledMessage_maxlenof_enabled00);
05026     tolua_endmodule(tolua_S);
05027     #ifdef __cplusplus
05028     tolua_cclass(tolua_S,"SetVelocityMessage","fawkes::PanTiltInterface::SetVelocityMessage","Message",tolua_collect_fawkes__PanTiltInterface__SetVelocityMessage);
05029     #else
05030     tolua_cclass(tolua_S,"SetVelocityMessage","fawkes::PanTiltInterface::SetVelocityMessage","Message",NULL);
05031     #endif
05032     tolua_beginmodule(tolua_S,"SetVelocityMessage");
05033      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new00);
05034      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new00_local);
05035      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new00_local);
05036      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new01);
05037      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new01_local);
05038      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_new01_local);
05039      tolua_function(tolua_S,"delete",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_delete00);
05040      tolua_function(tolua_S,"pan_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_pan_velocity00);
05041      tolua_function(tolua_S,"set_pan_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_set_pan_velocity00);
05042      tolua_function(tolua_S,"maxlenof_pan_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_maxlenof_pan_velocity00);
05043      tolua_function(tolua_S,"tilt_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_tilt_velocity00);
05044      tolua_function(tolua_S,"set_tilt_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_set_tilt_velocity00);
05045      tolua_function(tolua_S,"maxlenof_tilt_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetVelocityMessage_maxlenof_tilt_velocity00);
05046     tolua_endmodule(tolua_S);
05047     #ifdef __cplusplus
05048     tolua_cclass(tolua_S,"SetMarginMessage","fawkes::PanTiltInterface::SetMarginMessage","Message",tolua_collect_fawkes__PanTiltInterface__SetMarginMessage);
05049     #else
05050     tolua_cclass(tolua_S,"SetMarginMessage","fawkes::PanTiltInterface::SetMarginMessage","Message",NULL);
05051     #endif
05052     tolua_beginmodule(tolua_S,"SetMarginMessage");
05053      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new00);
05054      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new00_local);
05055      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new00_local);
05056      tolua_function(tolua_S,"new",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new01);
05057      tolua_function(tolua_S,"new_local",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new01_local);
05058      tolua_function(tolua_S,".call",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_new01_local);
05059      tolua_function(tolua_S,"delete",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_delete00);
05060      tolua_function(tolua_S,"pan_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_pan_margin00);
05061      tolua_function(tolua_S,"set_pan_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_set_pan_margin00);
05062      tolua_function(tolua_S,"maxlenof_pan_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_maxlenof_pan_margin00);
05063      tolua_function(tolua_S,"tilt_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_tilt_margin00);
05064      tolua_function(tolua_S,"set_tilt_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_set_tilt_margin00);
05065      tolua_function(tolua_S,"maxlenof_tilt_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_SetMarginMessage_maxlenof_tilt_margin00);
05066     tolua_endmodule(tolua_S);
05067     tolua_function(tolua_S,"flags",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_flags00);
05068     tolua_function(tolua_S,"set_flags",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_flags00);
05069     tolua_function(tolua_S,"maxlenof_flags",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_flags00);
05070     tolua_function(tolua_S,"pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_pan00);
05071     tolua_function(tolua_S,"set_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_pan00);
05072     tolua_function(tolua_S,"maxlenof_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_pan00);
05073     tolua_function(tolua_S,"tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_tilt00);
05074     tolua_function(tolua_S,"set_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_tilt00);
05075     tolua_function(tolua_S,"maxlenof_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_tilt00);
05076     tolua_function(tolua_S,"msgid",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgid00);
05077     tolua_function(tolua_S,"set_msgid",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_msgid00);
05078     tolua_function(tolua_S,"maxlenof_msgid",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_msgid00);
05079     tolua_function(tolua_S,"is_final",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_final00);
05080     tolua_function(tolua_S,"set_final",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_final00);
05081     tolua_function(tolua_S,"maxlenof_final",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_final00);
05082     tolua_function(tolua_S,"error_code",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_error_code00);
05083     tolua_function(tolua_S,"set_error_code",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_error_code00);
05084     tolua_function(tolua_S,"maxlenof_error_code",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_error_code00);
05085     tolua_function(tolua_S,"is_enabled",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_enabled00);
05086     tolua_function(tolua_S,"set_enabled",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_enabled00);
05087     tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_enabled00);
05088     tolua_function(tolua_S,"is_calibrated",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_calibrated00);
05089     tolua_function(tolua_S,"set_calibrated",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_calibrated00);
05090     tolua_function(tolua_S,"maxlenof_calibrated",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_calibrated00);
05091     tolua_function(tolua_S,"min_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_min_pan00);
05092     tolua_function(tolua_S,"set_min_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_min_pan00);
05093     tolua_function(tolua_S,"maxlenof_min_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_min_pan00);
05094     tolua_function(tolua_S,"max_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_pan00);
05095     tolua_function(tolua_S,"set_max_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_pan00);
05096     tolua_function(tolua_S,"maxlenof_max_pan",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_pan00);
05097     tolua_function(tolua_S,"min_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_min_tilt00);
05098     tolua_function(tolua_S,"set_min_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_min_tilt00);
05099     tolua_function(tolua_S,"maxlenof_min_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_min_tilt00);
05100     tolua_function(tolua_S,"max_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_tilt00);
05101     tolua_function(tolua_S,"set_max_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_tilt00);
05102     tolua_function(tolua_S,"maxlenof_max_tilt",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_tilt00);
05103     tolua_function(tolua_S,"max_pan_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_pan_velocity00);
05104     tolua_function(tolua_S,"set_max_pan_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_pan_velocity00);
05105     tolua_function(tolua_S,"maxlenof_max_pan_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_pan_velocity00);
05106     tolua_function(tolua_S,"max_tilt_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_max_tilt_velocity00);
05107     tolua_function(tolua_S,"set_max_tilt_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_max_tilt_velocity00);
05108     tolua_function(tolua_S,"maxlenof_max_tilt_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_max_tilt_velocity00);
05109     tolua_function(tolua_S,"pan_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_pan_velocity00);
05110     tolua_function(tolua_S,"set_pan_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_pan_velocity00);
05111     tolua_function(tolua_S,"maxlenof_pan_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_pan_velocity00);
05112     tolua_function(tolua_S,"tilt_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_tilt_velocity00);
05113     tolua_function(tolua_S,"set_tilt_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_tilt_velocity00);
05114     tolua_function(tolua_S,"maxlenof_tilt_velocity",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_tilt_velocity00);
05115     tolua_function(tolua_S,"pan_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_pan_margin00);
05116     tolua_function(tolua_S,"set_pan_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_pan_margin00);
05117     tolua_function(tolua_S,"maxlenof_pan_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_pan_margin00);
05118     tolua_function(tolua_S,"tilt_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_tilt_margin00);
05119     tolua_function(tolua_S,"set_tilt_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_tilt_margin00);
05120     tolua_function(tolua_S,"maxlenof_tilt_margin",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_maxlenof_tilt_margin00);
05121     tolua_function(tolua_S,"oftype",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_oftype00);
05122     tolua_function(tolua_S,"datachunk",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_datachunk00);
05123     tolua_function(tolua_S,"datasize",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_datasize00);
05124     tolua_function(tolua_S,"type",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_type00);
05125     tolua_function(tolua_S,"id",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_id00);
05126     tolua_function(tolua_S,"uid",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_uid00);
05127     tolua_function(tolua_S,"serial",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_serial00);
05128     tolua_function(tolua_S,"mem_serial",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_mem_serial00);
05129     tolua_function(tolua_S,".eq",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface__eq00);
05130     tolua_function(tolua_S,"hash",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_hash00);
05131     tolua_function(tolua_S,"hash_size",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_hash_size00);
05132     tolua_function(tolua_S,"hash_printable",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_hash_printable00);
05133     tolua_function(tolua_S,"is_writer",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_is_writer00);
05134     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_set_from_chunk00);
05135     tolua_function(tolua_S,"create_message",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_create_message00);
05136     tolua_function(tolua_S,"read",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_read00);
05137     tolua_function(tolua_S,"write",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_write00);
05138     tolua_function(tolua_S,"has_writer",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_has_writer00);
05139     tolua_function(tolua_S,"num_readers",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_num_readers00);
05140     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_enqueue_copy00);
05141     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_remove00);
05142     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_remove01);
05143     tolua_function(tolua_S,"msgq_size",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_size00);
05144     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_flush00);
05145     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_lock00);
05146     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_try_lock00);
05147     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_unlock00);
05148     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_pop00);
05149     tolua_function(tolua_S,"msgq_first",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_first00);
05150     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_PanTiltInterface_fawkes_PanTiltInterface_msgq_empty00);
05151    tolua_endmodule(tolua_S);
05152   tolua_endmodule(tolua_S);
05153  tolua_endmodule(tolua_S);
05154  return 1;
05155 }
05156 
05157 
05158 extern "C" {
05159 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
05160  TOLUA_API int luaopen_interfaces_PanTiltInterface (lua_State* tolua_S) {
05161  return tolua_interfaces_PanTiltInterface_open(tolua_S);
05162 };
05163 #endif
05164 }
05165 
05166