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