ma.py

00001 # This file contains wrappers for the basic
00002 # functions in maapi.
00003 
00004 # If a function or constant is missing, look in ma_gen.py, it
00005 # might be there.
00006 
00007 """__NATIVE__
00008 #include <ma.h>
00009 
00010 #define POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid) \
00011     do \
00012     { \
00013         if ((retval) != PM_RET_OK) \
00014         { \
00015             heap_gcPopTempRoot((objid)); \
00016             return (retval); \
00017         } \
00018     } \
00019     while (0)
00020 
00021 """
00022 
00023 TRANS_NONE = 0
00024 TRANS_ROT90 = 5
00025 TRANS_ROT180 = 3
00026 TRANS_ROT270 = 6
00027 TRANS_MIRROR = 2
00028 TRANS_MIRROR_ROT90 = 7
00029 TRANS_MIRROR_ROT180 = 1
00030 TRANS_MIRROR_ROT270 = 4
00031 
00032 EVENT_TYPE_CLOSE = 1
00033 EVENT_TYPE_KEY_PRESSED = 2
00034 EVENT_TYPE_KEY_RELEASED = 3
00035 EVENT_TYPE_POINTER_PRESSED = 8
00036 EVENT_TYPE_POINTER_RELEASED = 9
00037 EVENT_TYPE_POINTER_DRAGGED = 10
00038 
00039 MAK_0 = 48
00040 MAK_1 = 49
00041 MAK_2 = 50
00042 MAK_3 = 51
00043 MAK_4 = 52
00044 MAK_5 = 53
00045 MAK_6 = 54
00046 MAK_7 = 55
00047 MAK_8 = 56
00048 MAK_9 = 57
00049 MAK_HASH = 35
00050 MAK_STAR = 42
00051 
00052 MAK_UP = 273
00053 MAK_DOWN = 274
00054 MAK_RIGHT = 275
00055 MAK_LEFT = 276
00056 MAK_FIRE = 284
00057 MAK_SOFTLEFT = 285
00058 MAK_SOFTRIGHT = 286
00059 
00060 MAKB_LEFT = 0x00001
00061 MAKB_UP = 0x00002
00062 MAKB_RIGHT = 0x00004
00063 MAKB_DOWN = 0x00008
00064 MAKB_FIRE = 0x00010
00065 MAKB_SOFTLEFT = 0x00020
00066 MAKB_SOFTRIGHT = 0x00040
00067 MAKB_0 = 0x00080
00068 MAKB_1 = 0x00100
00069 MAKB_2 = 0x00200
00070 MAKB_3 = 0x00400
00071 MAKB_4 = 0x00800
00072 MAKB_5 = 0x01000
00073 MAKB_6 = 0x02000
00074 MAKB_7 = 0x04000
00075 MAKB_8 = 0x08000
00076 MAKB_9 = 0x10000
00077 MAKB_ASTERISK = 0x20000
00078 MAKB_STAR = 0x20000
00079 MAKB_HASH = 0x40000
00080 MAKB_POUND = 0x40000
00081 MAKB_GRID = 0x40000
00082 MAKB_CLEAR = 0x80000
00083 
00084 def sin(x):
00085     """__NATIVE__
00086     /* Wrapper generated for: */
00087     /*   double sin(double x); */
00088 
00089     PmReturn_t retval = PM_RET_OK;
00090 
00091     double func_retval;
00092     pPmObj_t p_func_retval = C_NULL;
00093 
00094     double x;
00095     pPmObj_t p_x = C_NULL;
00096 
00097     /* If wrong number of args, raise TypeError */
00098     if (NATIVE_GET_NUM_ARGS() != 1)
00099     {
00100         PM_RAISE(retval, PM_RET_EX_TYPE);
00101         return retval;
00102     }
00103 
00104     /* Raise TypeError if arg is not correct type */
00105     p_x = NATIVE_GET_LOCAL(0);
00106     if (OBJ_GET_TYPE(p_x) != OBJ_TYPE_FLT)
00107     {
00108         PM_RAISE(retval, PM_RET_EX_TYPE);
00109         return retval;
00110     }
00111 
00112     x = (double)(((pPmFloat_t)p_x)->val);
00113 
00114     func_retval = sin(x);
00115     retval = float_new(func_retval, &p_func_retval);
00116 
00117     NATIVE_SET_TOS(p_func_retval);
00118 
00119     return retval;
00120     """
00121     pass
00122 
00123 
00124 def maSetColor(rgb):
00125     """__NATIVE__
00126     /* Wrapper generated for: */
00127     /*   int maSetColor(int rgb); */
00128 
00129     PmReturn_t retval = PM_RET_OK;
00130 
00131     int func_retval;
00132     pPmObj_t p_func_retval = C_NULL;
00133 
00134     int rgb;
00135     pPmObj_t p_rgb = C_NULL;
00136 
00137     /* If wrong number of args, raise TypeError */
00138     if (NATIVE_GET_NUM_ARGS() != 1)
00139     {
00140         PM_RAISE(retval, PM_RET_EX_TYPE);
00141         return retval;
00142     }
00143 
00144     /* Raise TypeError if arg is not correct type */
00145     p_rgb = NATIVE_GET_LOCAL(0);
00146     if (OBJ_GET_TYPE(p_rgb) != OBJ_TYPE_INT)
00147     {
00148         PM_RAISE(retval, PM_RET_EX_TYPE);
00149         return retval;
00150     }
00151 
00152     rgb = ((pPmInt_t)p_rgb)->val;
00153 
00154     func_retval = maSetColor(rgb);
00155     retval = int_new(func_retval, &p_func_retval);
00156 
00157     NATIVE_SET_TOS(p_func_retval);
00158 
00159     return retval;
00160     """
00161     pass
00162 
00163 
00164 def maSetClipRect(left, top, width, height):
00165     """__NATIVE__
00166     /* Wrapper generated for: */
00167     /*   void maSetClipRect(int left, int top, int width, int height); */
00168 
00169     PmReturn_t retval = PM_RET_OK;
00170 
00171     pPmObj_t p_func_retval = C_NULL;
00172 
00173     int left;
00174     pPmObj_t p_left = C_NULL;
00175 
00176     int top;
00177     pPmObj_t p_top = C_NULL;
00178 
00179     int width;
00180     pPmObj_t p_width = C_NULL;
00181 
00182     int height;
00183     pPmObj_t p_height = C_NULL;
00184 
00185     /* If wrong number of args, raise TypeError */
00186     if (NATIVE_GET_NUM_ARGS() != 4)
00187     {
00188         PM_RAISE(retval, PM_RET_EX_TYPE);
00189         return retval;
00190     }
00191 
00192     /* Raise TypeError if arg is not correct type */
00193     p_left = NATIVE_GET_LOCAL(0);
00194     if (OBJ_GET_TYPE(p_left) != OBJ_TYPE_INT)
00195     {
00196         PM_RAISE(retval, PM_RET_EX_TYPE);
00197         return retval;
00198     }
00199 
00200     /* Raise TypeError if arg is not correct type */
00201     p_top = NATIVE_GET_LOCAL(1);
00202     if (OBJ_GET_TYPE(p_top) != OBJ_TYPE_INT)
00203     {
00204         PM_RAISE(retval, PM_RET_EX_TYPE);
00205         return retval;
00206     }
00207 
00208     /* Raise TypeError if arg is not correct type */
00209     p_width = NATIVE_GET_LOCAL(2);
00210     if (OBJ_GET_TYPE(p_width) != OBJ_TYPE_INT)
00211     {
00212         PM_RAISE(retval, PM_RET_EX_TYPE);
00213         return retval;
00214     }
00215 
00216     /* Raise TypeError if arg is not correct type */
00217     p_height = NATIVE_GET_LOCAL(3);
00218     if (OBJ_GET_TYPE(p_height) != OBJ_TYPE_INT)
00219     {
00220         PM_RAISE(retval, PM_RET_EX_TYPE);
00221         return retval;
00222     }
00223 
00224     left = ((pPmInt_t)p_left)->val;
00225     top = ((pPmInt_t)p_top)->val;
00226     width = ((pPmInt_t)p_width)->val;
00227     height = ((pPmInt_t)p_height)->val;
00228 
00229     maSetClipRect(left, top, width, height);
00230 
00231     NATIVE_SET_TOS(PM_NONE);
00232 
00233     return retval;
00234     """
00235     pass
00236 
00237 
00238 def maGetClipRect():
00239     """__NATIVE__
00240     /* Wrapper generated for: */
00241     /*   void maGetClipRect(MARect* out); */
00242 
00243     PmReturn_t retval = PM_RET_OK;
00244 
00245     MARect rect;
00246     pPmObj_t pn = C_NULL;
00247     pPmObj_t r_ptuple = C_NULL;
00248     uint8_t objid;
00249 
00250     /* If wrong number of args, raise TypeError */
00251     if (NATIVE_GET_NUM_ARGS() != 0)
00252     {
00253         PM_RAISE(retval, PM_RET_EX_TYPE);
00254         return retval;
00255     }
00256 
00257     maGetClipRect(&rect);
00258     retval = tuple_new(4, &r_ptuple);
00259     PM_RETURN_IF_ERROR(retval);
00260     heap_gcPushTempRoot(r_ptuple, &objid);
00261     retval = int_new(rect.left, &pn);
00262     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00263     ((pPmTuple_t)r_ptuple)->val[0] = pn;
00264     retval = int_new(rect.top, &pn);
00265     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00266     ((pPmTuple_t)r_ptuple)->val[1] = pn;
00267     retval = int_new(rect.width, &pn);
00268     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00269     ((pPmTuple_t)r_ptuple)->val[2] = pn;
00270     retval = int_new(rect.height, &pn);
00271     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00272     ((pPmTuple_t)r_ptuple)->val[3] = pn;
00273     heap_gcPopTempRoot(objid);
00274 
00275     NATIVE_SET_TOS(r_ptuple);
00276 
00277     return retval;
00278     """
00279     pass
00280 
00281 
00282 def maPlot(posX, posY):
00283     """__NATIVE__
00284     /* Wrapper generated for: */
00285     /*   void maPlot(int posX, int posY); */
00286 
00287     PmReturn_t retval = PM_RET_OK;
00288 
00289     pPmObj_t p_func_retval = C_NULL;
00290 
00291     int posX;
00292     pPmObj_t p_posX = C_NULL;
00293 
00294     int posY;
00295     pPmObj_t p_posY = C_NULL;
00296 
00297     /* If wrong number of args, raise TypeError */
00298     if (NATIVE_GET_NUM_ARGS() != 2)
00299     {
00300         PM_RAISE(retval, PM_RET_EX_TYPE);
00301         return retval;
00302     }
00303 
00304     /* Raise TypeError if arg is not correct type */
00305     p_posX = NATIVE_GET_LOCAL(0);
00306     if (OBJ_GET_TYPE(p_posX) != OBJ_TYPE_INT)
00307     {
00308         PM_RAISE(retval, PM_RET_EX_TYPE);
00309         return retval;
00310     }
00311 
00312     /* Raise TypeError if arg is not correct type */
00313     p_posY = NATIVE_GET_LOCAL(1);
00314     if (OBJ_GET_TYPE(p_posY) != OBJ_TYPE_INT)
00315     {
00316         PM_RAISE(retval, PM_RET_EX_TYPE);
00317         return retval;
00318     }
00319 
00320     posX = ((pPmInt_t)p_posX)->val;
00321     posY = ((pPmInt_t)p_posY)->val;
00322 
00323     maPlot(posX, posY);
00324 
00325     NATIVE_SET_TOS(PM_NONE);
00326 
00327     return retval;
00328     """
00329     pass
00330 
00331 
00332 def maLine(startX, startY, endX, endY):
00333     """__NATIVE__
00334     /* Wrapper generated for: */
00335     /*   void maLine(int startX, int startY, int endX, int endY); */
00336 
00337     PmReturn_t retval = PM_RET_OK;
00338 
00339     pPmObj_t p_func_retval = C_NULL;
00340 
00341     int startX;
00342     pPmObj_t p_startX = C_NULL;
00343 
00344     int startY;
00345     pPmObj_t p_startY = C_NULL;
00346 
00347     int endX;
00348     pPmObj_t p_endX = C_NULL;
00349 
00350     int endY;
00351     pPmObj_t p_endY = C_NULL;
00352 
00353     /* If wrong number of args, raise TypeError */
00354     if (NATIVE_GET_NUM_ARGS() != 4)
00355     {
00356         PM_RAISE(retval, PM_RET_EX_TYPE);
00357         return retval;
00358     }
00359 
00360     /* Raise TypeError if arg is not correct type */
00361     p_startX = NATIVE_GET_LOCAL(0);
00362     if (OBJ_GET_TYPE(p_startX) != OBJ_TYPE_INT)
00363     {
00364         PM_RAISE(retval, PM_RET_EX_TYPE);
00365         return retval;
00366     }
00367 
00368     /* Raise TypeError if arg is not correct type */
00369     p_startY = NATIVE_GET_LOCAL(1);
00370     if (OBJ_GET_TYPE(p_startY) != OBJ_TYPE_INT)
00371     {
00372         PM_RAISE(retval, PM_RET_EX_TYPE);
00373         return retval;
00374     }
00375 
00376     /* Raise TypeError if arg is not correct type */
00377     p_endX = NATIVE_GET_LOCAL(2);
00378     if (OBJ_GET_TYPE(p_endX) != OBJ_TYPE_INT)
00379     {
00380         PM_RAISE(retval, PM_RET_EX_TYPE);
00381         return retval;
00382     }
00383 
00384     /* Raise TypeError if arg is not correct type */
00385     p_endY = NATIVE_GET_LOCAL(3);
00386     if (OBJ_GET_TYPE(p_endY) != OBJ_TYPE_INT)
00387     {
00388         PM_RAISE(retval, PM_RET_EX_TYPE);
00389         return retval;
00390     }
00391 
00392     startX = ((pPmInt_t)p_startX)->val;
00393     startY = ((pPmInt_t)p_startY)->val;
00394     endX = ((pPmInt_t)p_endX)->val;
00395     endY = ((pPmInt_t)p_endY)->val;
00396 
00397     maLine(startX, startY, endX, endY);
00398 
00399     NATIVE_SET_TOS(PM_NONE);
00400 
00401     return retval;
00402     """
00403     pass
00404 
00405 
00406 def maFillRect(left, top, width, height):
00407     """__NATIVE__
00408     /* Wrapper generated for: */
00409     /*   void maFillRect(int left, int top, int width, int height); */
00410 
00411     PmReturn_t retval = PM_RET_OK;
00412 
00413     pPmObj_t p_func_retval = C_NULL;
00414 
00415     int left;
00416     pPmObj_t p_left = C_NULL;
00417 
00418     int top;
00419     pPmObj_t p_top = C_NULL;
00420 
00421     int width;
00422     pPmObj_t p_width = C_NULL;
00423 
00424     int height;
00425     pPmObj_t p_height = C_NULL;
00426 
00427     /* If wrong number of args, raise TypeError */
00428     if (NATIVE_GET_NUM_ARGS() != 4)
00429     {
00430         PM_RAISE(retval, PM_RET_EX_TYPE);
00431         return retval;
00432     }
00433 
00434     /* Raise TypeError if arg is not correct type */
00435     p_left = NATIVE_GET_LOCAL(0);
00436     if (OBJ_GET_TYPE(p_left) != OBJ_TYPE_INT)
00437     {
00438         PM_RAISE(retval, PM_RET_EX_TYPE);
00439         return retval;
00440     }
00441 
00442     /* Raise TypeError if arg is not correct type */
00443     p_top = NATIVE_GET_LOCAL(1);
00444     if (OBJ_GET_TYPE(p_top) != OBJ_TYPE_INT)
00445     {
00446         PM_RAISE(retval, PM_RET_EX_TYPE);
00447         return retval;
00448     }
00449 
00450     /* Raise TypeError if arg is not correct type */
00451     p_width = NATIVE_GET_LOCAL(2);
00452     if (OBJ_GET_TYPE(p_width) != OBJ_TYPE_INT)
00453     {
00454         PM_RAISE(retval, PM_RET_EX_TYPE);
00455         return retval;
00456     }
00457 
00458     /* Raise TypeError if arg is not correct type */
00459     p_height = NATIVE_GET_LOCAL(3);
00460     if (OBJ_GET_TYPE(p_height) != OBJ_TYPE_INT)
00461     {
00462         PM_RAISE(retval, PM_RET_EX_TYPE);
00463         return retval;
00464     }
00465 
00466     left = ((pPmInt_t)p_left)->val;
00467     top = ((pPmInt_t)p_top)->val;
00468     width = ((pPmInt_t)p_width)->val;
00469     height = ((pPmInt_t)p_height)->val;
00470 
00471     maFillRect(left, top, width, height);
00472 
00473     NATIVE_SET_TOS(PM_NONE);
00474 
00475     return retval;
00476     """
00477     pass
00478 
00479 # No wrapper for
00480 #void maFillTriangleStrip(const MAPoint2d* points, int count);
00481 
00482 # No wrapper for
00483 #void maFillTriangleFan(const MAPoint2d* points, int count);
00484 
00485 
00486 def maGetTextSize(s):
00487     """__NATIVE__
00488     /* Wrapper generated for: */
00489     /*   MAExtent maGetTextSize(const char* str); */
00490 
00491     PmReturn_t retval = PM_RET_OK;
00492 
00493     int extent;
00494     pPmObj_t pn = C_NULL;
00495     pPmObj_t r_ptuple = C_NULL;
00496     uint8_t objid;
00497 
00498     const char* str;
00499     pPmObj_t p_str = C_NULL;
00500 
00501     /* If wrong number of args, raise TypeError */
00502     if (NATIVE_GET_NUM_ARGS() != 1)
00503     {
00504         PM_RAISE(retval, PM_RET_EX_TYPE);
00505         return retval;
00506     }
00507 
00508     /* Raise TypeError if arg is not correct type */
00509     p_str = NATIVE_GET_LOCAL(0);
00510     if (OBJ_GET_TYPE(p_str) != OBJ_TYPE_STR)
00511     {
00512         PM_RAISE(retval, PM_RET_EX_TYPE);
00513         return retval;
00514     }
00515 
00516     str = (char const *)&(((pPmString_t)p_str)->val);
00517 
00518     extent = maGetTextSize(str);
00519     retval = tuple_new(2, &r_ptuple);
00520     PM_RETURN_IF_ERROR(retval);
00521     heap_gcPushTempRoot(r_ptuple, &objid);
00522     retval = int_new(EXTENT_X(extent), &pn);
00523     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00524     ((pPmTuple_t)r_ptuple)->val[0] = pn;
00525     retval = int_new(EXTENT_Y(extent), &pn);
00526     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00527     ((pPmTuple_t)r_ptuple)->val[1] = pn;
00528     heap_gcPopTempRoot(objid);
00529 
00530     NATIVE_SET_TOS(r_ptuple);
00531 
00532     return retval;
00533     """
00534     pass
00535 
00536 
00537 def maDrawText(left, top, s):
00538     """__NATIVE__
00539     /* Wrapper generated for: */
00540     /*   void maDrawText(int left, int top, const char* str); */
00541 
00542     PmReturn_t retval = PM_RET_OK;
00543 
00544     pPmObj_t p_func_retval = C_NULL;
00545 
00546     int left;
00547     pPmObj_t p_left = C_NULL;
00548 
00549     int top;
00550     pPmObj_t p_top = C_NULL;
00551 
00552     const char* str;
00553     pPmObj_t p_str = C_NULL;
00554 
00555     /* If wrong number of args, raise TypeError */
00556     if (NATIVE_GET_NUM_ARGS() != 3)
00557     {
00558         PM_RAISE(retval, PM_RET_EX_TYPE);
00559         return retval;
00560     }
00561 
00562     /* Raise TypeError if arg is not correct type */
00563     p_left = NATIVE_GET_LOCAL(0);
00564     if (OBJ_GET_TYPE(p_left) != OBJ_TYPE_INT)
00565     {
00566         PM_RAISE(retval, PM_RET_EX_TYPE);
00567         return retval;
00568     }
00569 
00570     /* Raise TypeError if arg is not correct type */
00571     p_top = NATIVE_GET_LOCAL(1);
00572     if (OBJ_GET_TYPE(p_top) != OBJ_TYPE_INT)
00573     {
00574         PM_RAISE(retval, PM_RET_EX_TYPE);
00575         return retval;
00576     }
00577 
00578     /* Raise TypeError if arg is not correct type */
00579     p_str = NATIVE_GET_LOCAL(2);
00580     if (OBJ_GET_TYPE(p_str) != OBJ_TYPE_STR)
00581     {
00582         PM_RAISE(retval, PM_RET_EX_TYPE);
00583         return retval;
00584     }
00585 
00586     left = ((pPmInt_t)p_left)->val;
00587     top = ((pPmInt_t)p_top)->val;
00588     str = (char const *)&(((pPmString_t)p_str)->val);
00589 
00590     maDrawText(left, top, str);
00591 
00592     NATIVE_SET_TOS(PM_NONE);
00593 
00594     return retval;
00595     """
00596     pass
00597 
00598 
00599 def maUpdateScreen():
00600     """__NATIVE__
00601     /* Wrapper generated for: */
00602     /*   void maUpdateScreen(void); */
00603 
00604     PmReturn_t retval = PM_RET_OK;
00605 
00606     pPmObj_t p_func_retval = C_NULL;
00607 
00608     /* If wrong number of args, raise TypeError */
00609     if (NATIVE_GET_NUM_ARGS() != 0)
00610     {
00611         PM_RAISE(retval, PM_RET_EX_TYPE);
00612         return retval;
00613     }
00614 
00615     maUpdateScreen();
00616     NATIVE_SET_TOS(PM_NONE);
00617     return retval;
00618     """
00619     pass
00620 
00621 
00622 def maGetScrSize():
00623     """__NATIVE__
00624     /* Wrapper generated for: */
00625     /*   MAExtent maGetScrSize(void); */
00626 
00627     PmReturn_t retval = PM_RET_OK;
00628 
00629     int extent;
00630     pPmObj_t pn = C_NULL;
00631     pPmObj_t r_ptuple = C_NULL;
00632     uint8_t objid;
00633 
00634     /* If wrong number of args, raise TypeError */
00635     if (NATIVE_GET_NUM_ARGS() != 0)
00636     {
00637         PM_RAISE(retval, PM_RET_EX_TYPE);
00638         return retval;
00639     }
00640 
00641 
00642     extent = maGetScrSize();
00643     retval = tuple_new(2, &r_ptuple);
00644     PM_RETURN_IF_ERROR(retval);
00645     heap_gcPushTempRoot(r_ptuple, &objid);
00646     retval = int_new(EXTENT_X(extent), &pn);
00647     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00648     ((pPmTuple_t)r_ptuple)->val[0] = pn;
00649     retval = int_new(EXTENT_Y(extent), &pn);
00650     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00651     ((pPmTuple_t)r_ptuple)->val[1] = pn;
00652     heap_gcPopTempRoot(objid);
00653 
00654     NATIVE_SET_TOS(r_ptuple);
00655 
00656     return retval;
00657     """
00658     pass
00659 
00660 
00661 def maDrawImage(image, left, top):
00662     """__NATIVE__
00663     /* Wrapper generated for: */
00664     /*   void maDrawImage(MAHandle image, int left, int top); */
00665 
00666     PmReturn_t retval = PM_RET_OK;
00667 
00668     pPmObj_t p_func_retval = C_NULL;
00669 
00670     int image;
00671     pPmObj_t p_image = C_NULL;
00672 
00673     int left;
00674     pPmObj_t p_left = C_NULL;
00675 
00676     int top;
00677     pPmObj_t p_top = C_NULL;
00678 
00679     /* If wrong number of args, raise TypeError */
00680     if (NATIVE_GET_NUM_ARGS() != 3)
00681     {
00682         PM_RAISE(retval, PM_RET_EX_TYPE);
00683         return retval;
00684     }
00685 
00686     /* Raise TypeError if arg is not correct type */
00687     p_image = NATIVE_GET_LOCAL(0);
00688     if (OBJ_GET_TYPE(p_image) != OBJ_TYPE_INT)
00689     {
00690         PM_RAISE(retval, PM_RET_EX_TYPE);
00691         return retval;
00692     }
00693 
00694     /* Raise TypeError if arg is not correct type */
00695     p_left = NATIVE_GET_LOCAL(1);
00696     if (OBJ_GET_TYPE(p_left) != OBJ_TYPE_INT)
00697     {
00698         PM_RAISE(retval, PM_RET_EX_TYPE);
00699         return retval;
00700     }
00701 
00702     /* Raise TypeError if arg is not correct type */
00703     p_top = NATIVE_GET_LOCAL(2);
00704     if (OBJ_GET_TYPE(p_top) != OBJ_TYPE_INT)
00705     {
00706         PM_RAISE(retval, PM_RET_EX_TYPE);
00707         return retval;
00708     }
00709 
00710     image = ((pPmInt_t)p_image)->val;
00711     left = ((pPmInt_t)p_left)->val;
00712     top = ((pPmInt_t)p_top)->val;
00713 
00714     maDrawImage(image, left, top);
00715 
00716     NATIVE_SET_TOS(PM_NONE);
00717 
00718     return retval;
00719     """
00720     pass
00721 
00722 
00723 # No wrapper for
00724 #void maDrawRGB(const MAPoint2d* dstPoint, const void* src, const MARect* srcRect, int scanlength);
00725 
00726 def maDrawImageRegion(image, srcRect, dstPoint, transformMode):
00727     """__NATIVE__
00728     /* Wrapper generated for: */
00729     /*   void maDrawImageRegion(MAHandle image, const MARect* srcRect, 
00730          const MAPoint2d* dstPoint, int transformMode); */
00731 
00732     PmReturn_t retval = PM_RET_OK;
00733 
00734     int image;
00735     pPmObj_t p_image = C_NULL;
00736 
00737     pPmObj_t p_srcRect = C_NULL;
00738     MARect srcRect;
00739     //int srcLeft;
00740     //int srcTop;
00741     //int srcRight;
00742     //int srcBottom;
00743 
00744     pPmObj_t p_dstPoint = C_NULL;
00745     MAPoint2d dstPoint;
00746     //int srcLeft;
00747     //int srcTop;
00748 
00749     pPmObj_t p_transformMode = C_NULL;
00750     int transformMode;
00751 
00752     /* If wrong number of args, raise TypeError */
00753     if (NATIVE_GET_NUM_ARGS() != 4)
00754     {
00755         PM_RAISE(retval, PM_RET_EX_TYPE);
00756         return retval;
00757     }
00758 
00759     /* Raise TypeError if arg is not correct type */
00760     p_image = NATIVE_GET_LOCAL(0);
00761     if (OBJ_GET_TYPE(p_image) != OBJ_TYPE_INT)
00762     {
00763         PM_RAISE(retval, PM_RET_EX_TYPE);
00764         return retval;
00765     }
00766 
00767     /* Raise TypeError if arg is not correct type */
00768     p_srcRect = NATIVE_GET_LOCAL(1);
00769     if (OBJ_GET_TYPE(p_srcRect) != OBJ_TYPE_TUP ||
00770         ((pPmTuple_t)p_srcRect)->length != 4)
00771     {
00772         PM_RAISE(retval, PM_RET_EX_TYPE);
00773         return retval;
00774     }
00775 
00776     /* Raise TypeError if arg is not correct type */
00777     p_dstPoint = NATIVE_GET_LOCAL(2);
00778     if (OBJ_GET_TYPE(p_dstPoint) != OBJ_TYPE_TUP ||
00779         ((pPmTuple_t)p_dstPoint)->length != 2)
00780     {
00781         PM_RAISE(retval, PM_RET_EX_TYPE);
00782         return retval;
00783     }
00784 
00785     /* Raise TypeError if arg is not correct type */
00786     p_transformMode = NATIVE_GET_LOCAL(3);
00787     if (OBJ_GET_TYPE(p_transformMode) != OBJ_TYPE_INT)
00788     {
00789         PM_RAISE(retval, PM_RET_EX_TYPE);
00790         return retval;
00791     }
00792     image = ((pPmInt_t)p_image)->val;
00793     
00794     srcRect.left = ((pPmInt_t)(((pPmTuple_t)p_srcRect)->val[0]))->val;
00795     srcRect.top = ((pPmInt_t)(((pPmTuple_t)p_srcRect)->val[1]))->val;
00796     srcRect.width = ((pPmInt_t)(((pPmTuple_t)p_srcRect)->val[2]))->val;
00797     srcRect.height = ((pPmInt_t)(((pPmTuple_t)p_srcRect)->val[3]))->val;
00798 
00799     dstPoint.x = ((pPmInt_t)(((pPmTuple_t)p_dstPoint)->val[0]))->val;
00800     dstPoint.y = ((pPmInt_t)(((pPmTuple_t)p_dstPoint)->val[1]))->val;
00801 
00802     transformMode = ((pPmInt_t)p_transformMode)->val;
00803 
00804     maDrawImageRegion(image, &srcRect, &dstPoint, transformMode);
00805 
00806     NATIVE_SET_TOS(PM_NONE);
00807 
00808     return retval;
00809     """
00810     pass
00811 
00812 
00813 def maGetImageSize(image):
00814     """__NATIVE__
00815     /* Wrapper generated for: */
00816     /*   MAExtent maGetImageSize(MAHandle image); */
00817 
00818     PmReturn_t retval = PM_RET_OK;
00819 
00820     int extent;
00821     pPmObj_t pn = C_NULL;
00822     pPmObj_t r_ptuple = C_NULL;
00823     uint8_t objid;
00824 
00825     int image;
00826     pPmObj_t p_image = C_NULL;
00827 
00828     /* If wrong number of args, raise TypeError */
00829     if (NATIVE_GET_NUM_ARGS() != 1)
00830     {
00831         PM_RAISE(retval, PM_RET_EX_TYPE);
00832         return retval;
00833     }
00834 
00835     /* Raise TypeError if arg is not correct type */
00836     p_image = NATIVE_GET_LOCAL(0);
00837     if (OBJ_GET_TYPE(p_image) != OBJ_TYPE_INT)
00838     {
00839         PM_RAISE(retval, PM_RET_EX_TYPE);
00840         return retval;
00841     }
00842 
00843     image = ((pPmInt_t)p_image)->val;
00844 
00845     extent = maGetImageSize(image);
00846 
00847     retval = tuple_new(2, &r_ptuple);
00848     PM_RETURN_IF_ERROR(retval);
00849     heap_gcPushTempRoot(r_ptuple, &objid);
00850     retval = int_new(EXTENT_X(extent), &pn);
00851     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00852     ((pPmTuple_t)r_ptuple)->val[0] = pn;
00853     retval = int_new(EXTENT_Y(extent), &pn);
00854     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00855     ((pPmTuple_t)r_ptuple)->val[1] = pn;
00856     heap_gcPopTempRoot(objid);
00857 
00858     NATIVE_SET_TOS(r_ptuple);
00859 
00860     return retval;
00861     """
00862     pass
00863 
00864 
00865 # No wrapper for
00866 #void maGetImageData(MAHandle image, void* dst, const MARect* srcRect, int scanlength);
00867 
00868 #MAHandle maSetDrawTarget(MAHandle image);
00869 #int maFindLabel(const char* name);
00870 #int maCreateImageFromData(MAHandle placeholder, MAHandle data, int offset, int size);
00871 
00872 # No wrapper for
00873 #int maCreateImageRaw(MAHandle placeholder, const void* src, MAExtent size, int alpha);
00874 
00875 #int maCreateDrawableImage(MAHandle placeholder, int width, int height);
00876 #int maCreateData(MAHandle placeholder, int size);
00877 
00878 #MAHandle maCreatePlaceholder(void);
00879 #void maDestroyObject(MAHandle handle);
00880 #int maGetDataSize(MAHandle data);
00881 
00882 # No wrapper for
00883 #void maReadData(MAHandle data, void* dst, int offset, int size);
00884 
00885 # No wrapper for
00886 #void maWriteData(MAHandle data, const void* src, int offset, int size);
00887 
00888 # No wrapper for
00889 #void maCopyData(const MACopyData* params);
00890 
00891 #MAHandle maOpenStore(const char* name, int flags);
00892 #int maWriteStore(MAHandle store, MAHandle data);
00893 #int maReadStore(MAHandle store, MAHandle placeholder);
00894 #void maCloseStore(MAHandle store, int _remove);
00895 #MAHandle maConnect(const char* url);
00896 #void maConnClose(MAHandle conn);
00897 
00898 # No wrapper for
00899 #void maConnRead(MAHandle conn, void* dst, int size);
00900 
00901 # No wrapper for
00902 #void maConnWrite(MAHandle conn, const void* src, int size);
00903 
00904 #void maConnReadToData(MAHandle conn, MAHandle data, int offset, int size);
00905 #void maConnWriteFromData(MAHandle conn, MAHandle data, int offset, int size);
00906 
00907 # No wrapper for
00908 #int maConnGetAddr(MAHandle conn, MAConnAddr* addr);
00909 
00910 #MAHandle maHttpCreate(const char* url, int method);
00911 #void maHttpSetRequestHeader(MAHandle conn, const char* key, const char* value);
00912 
00913 # No wrapper for
00914 #int maHttpGetResponseHeader(MAHandle conn, const char* key, char* buffer, int bufSize);
00915 
00916 #void maHttpFinish(MAHandle conn);
00917 #int maLoadResources(MAHandle data);
00918 #void maLoadProgram(MAHandle data, int reload);
00919 
00920 
00921 def maGetKeys():
00922     """__NATIVE__
00923     /* Wrapper generated for: */
00924     /*   int maGetKeys(void); */
00925 
00926     PmReturn_t retval = PM_RET_OK;
00927 
00928     int func_retval;
00929     pPmObj_t p_func_retval = C_NULL;
00930 
00931     /* If wrong number of args, raise TypeError */
00932     if (NATIVE_GET_NUM_ARGS() != 0)
00933     {
00934         PM_RAISE(retval, PM_RET_EX_TYPE);
00935         return retval;
00936     }
00937 
00938 
00939     func_retval = maGetKeys();
00940     retval = int_new(func_retval, &p_func_retval);
00941 
00942     NATIVE_SET_TOS(p_func_retval);
00943 
00944     return retval;
00945     """
00946     pass
00947 
00948 def _maGetEvent():
00949     """__NATIVE__
00950     PmReturn_t retval;
00951     MAEvent event;
00952     int type;
00953     int v1;
00954     int v2;
00955     pPmObj_t p1;
00956     pPmObj_t p2;
00957     pPmObj_t p3;
00958     pPmObj_t r_ptuple;
00959     uint8_t objid;
00960 
00961     /* If wrong number of args, raise TypeError */
00962     if (NATIVE_GET_NUM_ARGS() != 0)
00963     {
00964         PM_RAISE(retval, PM_RET_EX_TYPE);
00965         return retval;
00966     }
00967 
00968     if (!maGetEvent(&event)) {
00969         NATIVE_SET_TOS(PM_NONE);
00970         return retval;
00971     }
00972 
00973     type = event.type;
00974     if (type == EVENT_TYPE_KEY_PRESSED ||
00975         type == EVENT_TYPE_KEY_RELEASED) {
00976         v1 = event.key;
00977         v2 = event.nativeKey;
00978     } else if (type == EVENT_TYPE_POINTER_PRESSED ||
00979                type == EVENT_TYPE_POINTER_DRAGGED ||
00980                type == EVENT_TYPE_POINTER_RELEASED) {
00981         v1 = event.point.x;
00982         v2 = event.point.y;
00983     }
00984 
00985     /* Allocate a tuple to store the return values */
00986     retval = tuple_new(3, &r_ptuple);
00987     PM_RETURN_IF_ERROR(retval);
00988 
00989     heap_gcPushTempRoot(r_ptuple, &objid);
00990     retval = int_new(type, &p1);
00991     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00992     ((pPmTuple_t)r_ptuple)->val[0] = p1;
00993     retval = int_new(v1, &p2);
00994     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00995     ((pPmTuple_t)r_ptuple)->val[1] = p2;
00996     retval = int_new(v2, &p3);
00997     POP_TMPROOT_AND_RETURN_IF_ERROR(retval, objid);
00998     ((pPmTuple_t)r_ptuple)->val[2] = p3;
00999     heap_gcPopTempRoot(objid);
01000 
01001     /* Return the tuple on the stack */
01002     NATIVE_SET_TOS(r_ptuple);
01003 
01004     return retval;
01005     """
01006     pass
01007 
01008 _pointer_events = {EVENT_TYPE_POINTER_PRESSED: 'Pointer Pressed',
01009                    EVENT_TYPE_POINTER_DRAGGED: 'Pointer Dragged',
01010                    EVENT_TYPE_POINTER_RELEASED: 'Pointer Released'}
01011 
01012 _key_events = {EVENT_TYPE_KEY_PRESSED: 'Key Pressed',
01013                EVENT_TYPE_KEY_RELEASED: 'Key Released'}
01014 
01015 class Event:
01016     def __init__(self, event_type):
01017         self.type = event_type
01018     def __str__(self):
01019         if self.type in _pointer_events:
01020             return '%s: x=%d y=%d' % (_pointer_events[self.type], self.x, self.y)
01021         elif self.type in _key_events:
01022             return ('%s: key=%d nativekey=%d' % 
01023                     (_key_events[self.type], self.key, self.nativekey))
01024         else:
01025             return 'Event type: %d' % self.type
01026 
01027 def maGetEvent():
01028     t = _maGetEvent()
01029     if not t:
01030         return None
01031     etype, v1, v2 = t
01032     event = Event(etype)
01033     if etype in [EVENT_TYPE_POINTER_PRESSED,
01034                  EVENT_TYPE_POINTER_DRAGGED,
01035                  EVENT_TYPE_POINTER_RELEASED]:
01036         event.x = v1
01037         event.y = v2
01038     elif etype in [EVENT_TYPE_KEY_PRESSED,
01039                   EVENT_TYPE_KEY_RELEASED]:
01040         event.key = v1
01041         event.nativekey = v2
01042     return event
01043 
01044 def maGetEvents():
01045     while True:
01046         event = maGetEvent()
01047         if event:
01048             yield event
01049         else:
01050             break
01051 
01052 def _maGetNone():
01053     """__NATIVE__
01054     PmReturn_t retval;
01055 
01056     /* If wrong number of args, raise TypeError */
01057     if (NATIVE_GET_NUM_ARGS() != 0)
01058     {
01059         PM_RAISE(retval, PM_RET_EX_TYPE);
01060         return retval;
01061     }
01062 
01063     NATIVE_SET_TOS(PM_NONE);
01064     return retval;
01065     """
01066     pass
01067 
01068 def maGetNone():
01069     return _maGetNone()
01070 
01071 def maWait(timeout):
01072     """__NATIVE__
01073     /* Wrapper generated for: */
01074     /*   void maWait(int timeout); */
01075 
01076     PmReturn_t retval = PM_RET_OK;
01077 
01078     pPmObj_t p_func_retval = C_NULL;
01079 
01080     int timeout;
01081     pPmObj_t p_timeout = C_NULL;
01082 
01083     /* If wrong number of args, raise TypeError */
01084     if (NATIVE_GET_NUM_ARGS() != 1)
01085     {
01086         PM_RAISE(retval, PM_RET_EX_TYPE);
01087         return retval;
01088     }
01089 
01090     /* Raise TypeError if arg is not correct type */
01091     p_timeout = NATIVE_GET_LOCAL(0);
01092     if (OBJ_GET_TYPE(p_timeout) != OBJ_TYPE_INT)
01093     {
01094         PM_RAISE(retval, PM_RET_EX_TYPE);
01095         return retval;
01096     }
01097 
01098     timeout = ((pPmInt_t)p_timeout)->val;
01099 
01100     maWait(timeout);
01101 
01102     NATIVE_SET_TOS(PM_NONE);
01103 
01104     return retval;
01105     """
01106     pass
01107 
01108 
01109 def maTime():
01110     """__NATIVE__
01111     /* Wrapper generated for: */
01112     /*   int maTime(void); */
01113 
01114     PmReturn_t retval = PM_RET_OK;
01115 
01116     int func_retval;
01117     pPmObj_t p_func_retval = C_NULL;
01118 
01119     /* If wrong number of args, raise TypeError */
01120     if (NATIVE_GET_NUM_ARGS() != 0)
01121     {
01122         PM_RAISE(retval, PM_RET_EX_TYPE);
01123         return retval;
01124     }
01125 
01126 
01127     func_retval = maTime();
01128     retval = int_new(func_retval, &p_func_retval);
01129 
01130     NATIVE_SET_TOS(p_func_retval);
01131 
01132     return retval;
01133     """
01134     pass
01135 
01136 
01137 def maLocalTime():
01138     """__NATIVE__
01139     /* Wrapper generated for: */
01140     /*   int maLocalTime(void); */
01141 
01142     PmReturn_t retval = PM_RET_OK;
01143 
01144     int func_retval;
01145     pPmObj_t p_func_retval = C_NULL;
01146 
01147     /* If wrong number of args, raise TypeError */
01148     if (NATIVE_GET_NUM_ARGS() != 0)
01149     {
01150         PM_RAISE(retval, PM_RET_EX_TYPE);
01151         return retval;
01152     }
01153 
01154 
01155     func_retval = maLocalTime();
01156     retval = int_new(func_retval, &p_func_retval);
01157 
01158     NATIVE_SET_TOS(p_func_retval);
01159 
01160     return retval;
01161     """
01162     pass
01163 
01164 
01165 def maGetMilliSecondCount():
01166     """__NATIVE__
01167     /* Wrapper generated for: */
01168     /*   int maGetMilliSecondCount(void); */
01169 
01170     PmReturn_t retval = PM_RET_OK;
01171 
01172     int func_retval;
01173     pPmObj_t p_func_retval = C_NULL;
01174 
01175     /* If wrong number of args, raise TypeError */
01176     if (NATIVE_GET_NUM_ARGS() != 0)
01177     {
01178         PM_RAISE(retval, PM_RET_EX_TYPE);
01179         return retval;
01180     }
01181 
01182 
01183     func_retval = maGetMilliSecondCount();
01184     retval = int_new(func_retval, &p_func_retval);
01185 
01186     NATIVE_SET_TOS(p_func_retval);
01187 
01188     return retval;
01189     """
01190     pass
01191 
01192 def maFreeObjectMemory():
01193     """__NATIVE__
01194     /* Wrapper generated for: */
01195     /*   int maFreeObjectMemory(void); */
01196 
01197     PmReturn_t retval = PM_RET_OK;
01198 
01199     int func_retval;
01200     pPmObj_t p_func_retval = C_NULL;
01201 
01202     /* If wrong number of args, raise TypeError */
01203     if (NATIVE_GET_NUM_ARGS() != 0)
01204     {
01205         PM_RAISE(retval, PM_RET_EX_TYPE);
01206         return retval;
01207     }
01208 
01209 
01210     func_retval = maFreeObjectMemory();
01211     retval = int_new(func_retval, &p_func_retval);
01212 
01213     NATIVE_SET_TOS(p_func_retval);
01214 
01215     return retval;
01216     """
01217     pass
01218 
01219 def maTotalObjectMemory():
01220     """__NATIVE__
01221     /* Wrapper generated for: */
01222     /*   int maTotalObjectMemory(void); */
01223 
01224     PmReturn_t retval = PM_RET_OK;
01225 
01226     int func_retval;
01227     pPmObj_t p_func_retval = C_NULL;
01228 
01229     /* If wrong number of args, raise TypeError */
01230     if (NATIVE_GET_NUM_ARGS() != 0)
01231     {
01232         PM_RAISE(retval, PM_RET_EX_TYPE);
01233         return retval;
01234     }
01235 
01236 
01237     func_retval = maTotalObjectMemory();
01238     retval = int_new(func_retval, &p_func_retval);
01239 
01240     NATIVE_SET_TOS(p_func_retval);
01241 
01242     return retval;
01243     """
01244     pass
01245 
01246 def maVibrate(ms):
01247     """__NATIVE__
01248     /* Wrapper generated for: */
01249     /*   int maVibrate(int ms); */
01250 
01251     PmReturn_t retval = PM_RET_OK;
01252 
01253     int func_retval;
01254     pPmObj_t p_func_retval = C_NULL;
01255 
01256     int ms;
01257     pPmObj_t p_ms = C_NULL;
01258 
01259     /* If wrong number of args, raise TypeError */
01260     if (NATIVE_GET_NUM_ARGS() != 1)
01261     {
01262         PM_RAISE(retval, PM_RET_EX_TYPE);
01263         return retval;
01264     }
01265 
01266     /* Raise TypeError if arg is not correct type */
01267     p_ms = NATIVE_GET_LOCAL(0);
01268     if (OBJ_GET_TYPE(p_ms) != OBJ_TYPE_INT)
01269     {
01270         PM_RAISE(retval, PM_RET_EX_TYPE);
01271         return retval;
01272     }
01273 
01274     ms = ((pPmInt_t)p_ms)->val;
01275 
01276     func_retval = maVibrate(ms);
01277     retval = int_new(func_retval, &p_func_retval);
01278 
01279     NATIVE_SET_TOS(p_func_retval);
01280 
01281     return retval;
01282     """
01283     pass
01284 
01285 
01286 def maSoundPlay(sound_res, offset, size):
01287     """__NATIVE__
01288     /* Wrapper generated for: */
01289     /*   int maSoundPlay(MAHandle sound_res, int offset, int size); */
01290 
01291     PmReturn_t retval = PM_RET_OK;
01292 
01293     int func_retval;
01294     pPmObj_t p_func_retval = C_NULL;
01295 
01296     int sound_res;
01297     pPmObj_t p_sound_res = C_NULL;
01298 
01299     int offset;
01300     pPmObj_t p_offset = C_NULL;
01301 
01302     int size;
01303     pPmObj_t p_size = C_NULL;
01304 
01305     /* If wrong number of args, raise TypeError */
01306     if (NATIVE_GET_NUM_ARGS() != 3)
01307     {
01308         PM_RAISE(retval, PM_RET_EX_TYPE);
01309         return retval;
01310     }
01311 
01312     /* Raise TypeError if arg is not correct type */
01313     p_sound_res = NATIVE_GET_LOCAL(0);
01314     if (OBJ_GET_TYPE(p_sound_res) != OBJ_TYPE_INT)
01315     {
01316         PM_RAISE(retval, PM_RET_EX_TYPE);
01317         return retval;
01318     }
01319 
01320     /* Raise TypeError if arg is not correct type */
01321     p_offset = NATIVE_GET_LOCAL(1);
01322     if (OBJ_GET_TYPE(p_offset) != OBJ_TYPE_INT)
01323     {
01324         PM_RAISE(retval, PM_RET_EX_TYPE);
01325         return retval;
01326     }
01327 
01328     /* Raise TypeError if arg is not correct type */
01329     p_size = NATIVE_GET_LOCAL(2);
01330     if (OBJ_GET_TYPE(p_size) != OBJ_TYPE_INT)
01331     {
01332         PM_RAISE(retval, PM_RET_EX_TYPE);
01333         return retval;
01334     }
01335 
01336     sound_res = ((pPmInt_t)p_sound_res)->val;
01337     offset = ((pPmInt_t)p_offset)->val;
01338     size = ((pPmInt_t)p_size)->val;
01339 
01340     func_retval = maSoundPlay(sound_res, offset, size);
01341     retval = int_new(func_retval, &p_func_retval);
01342 
01343     NATIVE_SET_TOS(p_func_retval);
01344 
01345     return retval;
01346     """
01347     pass
01348 
01349 
01350 def maSoundStop():
01351     """__NATIVE__
01352     /* Wrapper generated for: */
01353     /*   void maSoundStop(void); */
01354 
01355     PmReturn_t retval = PM_RET_OK;
01356 
01357     pPmObj_t p_func_retval = C_NULL;
01358 
01359     /* If wrong number of args, raise TypeError */
01360     if (NATIVE_GET_NUM_ARGS() != 0)
01361     {
01362         PM_RAISE(retval, PM_RET_EX_TYPE);
01363         return retval;
01364     }
01365 
01366 
01367     maSoundStop();
01368 
01369     NATIVE_SET_TOS(PM_NONE);
01370 
01371     return retval;
01372     """
01373     pass
01374 
01375 
01376 def maSoundIsPlaying():
01377     """__NATIVE__
01378     /* Wrapper generated for: */
01379     /*   int maSoundIsPlaying(void); */
01380 
01381     PmReturn_t retval = PM_RET_OK;
01382 
01383     int func_retval;
01384     pPmObj_t p_func_retval = C_NULL;
01385 
01386     /* If wrong number of args, raise TypeError */
01387     if (NATIVE_GET_NUM_ARGS() != 0)
01388     {
01389         PM_RAISE(retval, PM_RET_EX_TYPE);
01390         return retval;
01391     }
01392 
01393 
01394     func_retval = maSoundIsPlaying();
01395     retval = int_new(func_retval, &p_func_retval);
01396 
01397     NATIVE_SET_TOS(p_func_retval);
01398 
01399     return retval;
01400     """
01401     pass
01402 
01403 
01404 def maSoundGetVolume():
01405     """__NATIVE__
01406     /* Wrapper generated for: */
01407     /*   int maSoundGetVolume(void); */
01408 
01409     PmReturn_t retval = PM_RET_OK;
01410 
01411     int func_retval;
01412     pPmObj_t p_func_retval = C_NULL;
01413 
01414     /* If wrong number of args, raise TypeError */
01415     if (NATIVE_GET_NUM_ARGS() != 0)
01416     {
01417         PM_RAISE(retval, PM_RET_EX_TYPE);
01418         return retval;
01419     }
01420 
01421 
01422     func_retval = maSoundGetVolume();
01423     retval = int_new(func_retval, &p_func_retval);
01424 
01425     NATIVE_SET_TOS(p_func_retval);
01426 
01427     return retval;
01428     """
01429     pass
01430 
01431 
01432 def maSoundSetVolume(vol):
01433     """__NATIVE__
01434     /* Wrapper generated for: */
01435     /*   void maSoundSetVolume(int vol); */
01436 
01437     PmReturn_t retval = PM_RET_OK;
01438 
01439     pPmObj_t p_func_retval = C_NULL;
01440 
01441     int vol;
01442     pPmObj_t p_vol = C_NULL;
01443 
01444     /* If wrong number of args, raise TypeError */
01445     if (NATIVE_GET_NUM_ARGS() != 1)
01446     {
01447         PM_RAISE(retval, PM_RET_EX_TYPE);
01448         return retval;
01449     }
01450 
01451     /* Raise TypeError if arg is not correct type */
01452     p_vol = NATIVE_GET_LOCAL(0);
01453     if (OBJ_GET_TYPE(p_vol) != OBJ_TYPE_INT)
01454     {
01455         PM_RAISE(retval, PM_RET_EX_TYPE);
01456         return retval;
01457     }
01458 
01459     vol = ((pPmInt_t)p_vol)->val;
01460 
01461     maSoundSetVolume(vol);
01462 
01463     NATIVE_SET_TOS(PM_NONE);
01464 
01465     return retval;
01466     """
01467     pass
01468 
01469 #int maInvokeExtension(int function, int a, int b, int c);
01470 
01471 # This doesn't really belong here, but it plenty useful.
01472 def int(v):
01473     """__NATIVE__
01474 
01475     PmReturn_t retval = PM_RET_OK;
01476 
01477     int func_retval;
01478     pPmObj_t p_func_retval = C_NULL;
01479 
01480     int int_val;
01481     pPmObj_t p_float = C_NULL;
01482 
01483     /* If wrong number of args, raise TypeError */
01484     if (NATIVE_GET_NUM_ARGS() != 1)
01485     {
01486         PM_RAISE(retval, PM_RET_EX_TYPE);
01487         return retval;
01488     }
01489 
01490     /* Raise TypeError if arg is not correct type */
01491     p_float = NATIVE_GET_LOCAL(0);
01492     if (OBJ_GET_TYPE(p_float) != OBJ_TYPE_FLT)
01493     {
01494         PM_RAISE(retval, PM_RET_EX_TYPE);
01495         return retval;
01496     }
01497 
01498     int_val = (int)(((pPmFloat_t)p_float)->val);
01499 
01500     retval = int_new(int_val, &p_func_retval);
01501 
01502     NATIVE_SET_TOS(p_func_retval);
01503 
01504     return retval;
01505     """
01506     pass
01507 
01508 # Relatively cheap 16 bit pseudo randomness
01509 def rand():
01510     """__NATIVE__
01511     static unsigned long randx = 0x01234567;
01512     PmReturn_t retval = PM_RET_OK;
01513 
01514     int func_retval;
01515     pPmObj_t p_func_retval = C_NULL;
01516 
01517     /* If wrong number of args, raise TypeError */
01518     if (NATIVE_GET_NUM_ARGS() != 0)
01519     {
01520         PM_RAISE(retval, PM_RET_EX_TYPE);
01521         return retval;
01522     }
01523 
01524     randx *= 1103515245;
01525     randx += 12345;
01526     func_retval = (randx >> 16) & 0xffff;
01527     retval = int_new(func_retval, &p_func_retval);
01528 
01529     NATIVE_SET_TOS(p_func_retval);
01530 
01531     return retval;
01532     """
01533     pass
01534 
01535 def xrange(n):
01536     i = 0
01537     while i < n:
01538         yield i
01539         i += 1
01540 

Generated on Mon Oct 18 07:40:46 2010 for Python-on-a-chip by  doxygen 1.5.9