![]() |
![]() |
00001 /******************************************************************************* 00002 * GX IMAGE header file - v7.2.12 00003 * 00004 * 2004-2015 (c) Adaptive Recognition (https://adaptiverecognition.com) 00005 ******************************************************************************/ 00015 /******************************************************************************/ 00016 #ifndef GX_IMAGE_INCL 00017 #define GX_IMAGE_INCL 00018 /******************************************************************************/ 00019 #include "gxsd.h" 00020 #if defined(WIN32) && !defined(GX_DOTNET) 00021 #include <windows.h> 00022 #endif 00023 #include <assert.h> 00024 #include "gxerror.h" 00025 #include "gxvariant.h" 00026 /******************************************************************************/ 00027 #ifdef __BORLANDC__ 00028 #pragma warn -rch 00029 #endif 00030 /******************************************************************************/ 00031 #ifdef GX_NAMESPACES 00032 namespace gx { 00033 #endif 00034 /******************************************************************************/ 00035 #ifdef GX_DOTNET 00036 #pragma managed 00037 #endif 00038 /******************************************************************************/ 00039 #ifndef GX_EXT_MODULE /*(*/ 00040 /******************************************************************************/ 00042 GX_ENUM GX_PIXELFORMATS { 00043 GX_UNDEF = 0x0000, 00045 GX_GRAY = 0x0001, 00046 GX_RGB555 = 0x0002, 00047 GX_BGR555 = 0x0003, 00048 GX_RGB565 = 0x0004, 00049 GX_BGR565 = 0x0005, 00050 GX_RGB = 0x0006, 00051 GX_BGR = 0x0007, 00052 GX_RGBA = 0x0008, 00053 GX_BGRA = 0x0009, 00054 GX_YUV422 = 0x000A, 00055 GX_GRAY12 = 0x000B, 00056 GX_RGB12 = 0x000C, 00057 GX_BGR12 = 0x000D, 00058 GX_GBRG = 0x000E, 00059 GX_BGGR = 0x000F, 00060 GX_RGGB = 0x0010, 00061 GX_GRBG = 0x0011, 00063 GX_FORMAT_FIRST = GX_GRAY, 00064 GX_FORMAT_LAST = GX_GRBG 00065 }; 00066 00068 GX_ENUM GX_IMGFILEFORMATS { 00069 GX_BMP = 1, 00070 GX_JPEG = 2, 00071 GX_JPEG2K_JPC = 3, 00072 GX_JPEG2K_JP2 = 4, 00073 GX_JPEG2K = GX_JPEG2K_JP2, 00074 GX_RAW = 5, 00075 GX_PNG = 6, 00076 GX_WSQ = 7 00077 }; 00078 00080 GX_ENUM GX_MIRRORFLAGS { 00081 GX_MIRROR_NOMIRROR = 0, 00082 GX_MIRROR_HORIZONTAL = 1, 00083 GX_MIRROR_VERTICAL = 2 00084 }; 00085 00087 GX_ENUM GX_ZOOMMODES { 00088 GX_ZOOM_NEAREST = 0, 00089 GX_ZOOM_LINEAR = 1 00090 }; 00091 00093 GX_ENUM GX_QUICKCONVERT { 00094 GX_CONVERT_NORMAL = 0, 00095 GX_CONVERT_QUICK = 1 00096 }; 00097 00099 GX_ENUM GX_QUICKDISPLAY { 00100 GX_DISPLAY_NORMAL = 0, 00101 GX_DISPLAY_QUICK = 1 00102 }; 00103 00105 GX_ENUM GX_IMAGECOMMENTS { 00106 GX_IMGCOMM_GENERAL = 0, 00107 GX_IMGCOMM_JPEG_APP0, 00108 GX_IMGCOMM_JPEG_APP1, 00109 GX_IMGCOMM_JPEG_APP2, 00110 GX_IMGCOMM_JPEG_APP3, 00111 GX_IMGCOMM_JPEG_APP4, 00112 GX_IMGCOMM_JPEG_APP5, 00113 GX_IMGCOMM_JPEG_APP6, 00114 GX_IMGCOMM_JPEG_APP7, 00115 GX_IMGCOMM_JPEG_APP8, 00116 GX_IMGCOMM_JPEG_APP9, 00117 GX_IMGCOMM_JPEG_APP10, 00118 GX_IMGCOMM_JPEG_APP11, 00119 GX_IMGCOMM_JPEG_APP12, 00120 GX_IMGCOMM_JPEG_APP13, 00121 GX_IMGCOMM_JPEG_APP14, 00122 GX_IMGCOMM_JPEG_APP15, 00123 GX_IMGCOMM_INVALIDFORMAT 00124 }; 00125 00127 GX_ENUM GX_IMAGEPROPERTIES1 { 00128 GX_IMGPROP_BMP_FORCE24BPP = GX_CALL_GROUP_GX_BMP, 00135 GX_IMGPROP_BMP_ENABLERLE, 00142 GX_IMGPROP_JPEG_SCALE_NUM = GX_CALL_GROUP_GX_JPEG, 00143 GX_IMGPROP_JPEG_SCALE_DENOM, 00144 GX_IMGPROP_JPEG_DCT_METHOD, 00145 GX_IMGPROP_JPEG_DO_FANCY_UPSAMPLING, 00146 GX_IMGPROP_JPEG_DO_BLOCK_SMOOTHING, 00148 GX_IMGPROP_JPEG_QUALITY, 00149 GX_IMGPROP_JPEG_PROGRESSIVE, 00150 GX_IMGPROP_JPEG_OPTIMIZE_CODING, 00151 GX_IMGPROP_JPEG_RESTART_INTERVAL, 00152 GX_IMGPROP_JPEG_RESTART_IN_ROWS, 00153 GX_IMGPROP_JPEG_SMOOTHING_FACTOR, 00155 GX_IMGPROP_JPEG2K_IMGAREATLX = GX_CALL_GROUP_GX_JPEG2K, 00156 GX_IMGPROP_JPEG2K_IMGAREATLY, 00157 GX_IMGPROP_JPEG2K_TILEGRDTLX, 00158 GX_IMGPROP_JPEG2K_TILEGRDTLY, 00159 GX_IMGPROP_JPEG2K_TILEWIDTH, 00160 GX_IMGPROP_JPEG2K_TILEHEIGHT, 00161 GX_IMGPROP_JPEG2K_PRCWIDTH, 00162 GX_IMGPROP_JPEG2K_PRCHEIGHT, 00163 GX_IMGPROP_JPEG2K_CBLKWIDTH, 00164 GX_IMGPROP_JPEG2K_CBLKHEIGHT, 00165 GX_IMGPROP_JPEG2K_MODE, 00166 GX_IMGPROP_JPEG2K_RATE, 00167 GX_IMGPROP_JPEG2K_ILYRRATES, 00168 GX_IMGPROP_JPEG2K_PRG, 00169 GX_IMGPROP_JPEG2K_NOMCT, 00170 GX_IMGPROP_JPEG2K_NUMRLVLS, 00171 GX_IMGPROP_JPEG2K_SOP, 00172 GX_IMGPROP_JPEG2K_EPH, 00173 GX_IMGPROP_JPEG2K_LAZY, 00174 GX_IMGPROP_JPEG2K_TERMALL, 00175 GX_IMGPROP_JPEG2K_SEGSYM, 00176 GX_IMGPROP_JPEG2K_VCAUSAL, 00177 GX_IMGPROP_JPEG2K_PTERM, 00178 GX_IMGPROP_JPEG2K_RESETPROB, 00179 GX_IMGPROP_JPEG2K_NUMGBITS, 00181 GX_IMGPROP_WSQ_BITRATE = GX_CALL_GROUP_GX_WSQ 00182 }; 00183 /******************************************************************************/ 00184 #endif /*)*/ 00185 /******************************************************************************/ 00186 #if defined(GX_DOTNET) && !defined(GX_MANUAL) 00187 #pragma unmanaged 00188 #define gxIMAGE _gxIMAGE 00189 #define HDC void* 00190 #endif 00191 /******************************************************************************/ 00192 #if !defined(GX_SWIGIF) && !(defined(GX_MANUAL) && defined(GX_DOTNET)) /*(*/ 00193 00194 struct gxIMAGE { 00195 gxi32 gxid; 00196 gxi32 ref; 00197 void* image; 00198 gxi32 simage; 00199 gxi32 format; 00200 gxi32 xsize; 00201 gxi32 ysize; 00202 gxi32 sline; 00216 gxi32 xres; 00229 gxi32 yres; 00230 }; 00231 /******************************************************************************/ 00232 #ifndef __cplusplus 00233 typedef struct gxIMAGE gxIMAGE; 00234 #endif 00235 /******************************************************************************/ 00236 #endif /* GX_SWIGIF GX_MANUAL GX_DOTNET )*/ 00237 #if !defined(GX_SWIGIF) && !defined(GX_MANUAL) /*(*/ 00238 /******************************************************************************/ 00239 /* Call codes for image operations. */ 00240 enum { 00241 GX_CALL_GETPIXELSIZE = GX_CALL_GROUP_GX_IMAGE, 00242 GX_CALL_CONVERTPIXELS, 00243 GX_CALL_FASTRECONVERT, 00244 GX_CALL_ZOOMPIXELS, 00245 GX_CALL_ROTATEPIXELS, 00246 GX_CALL_MIRRORPIXELS, 00247 GX_CALL_INITIMAGE, 00248 GX_CALL_ALLOCIMAGE, 00249 GX_CALL_FREEIMAGE, 00250 GX_CALL_REFIMAGE, 00251 GX_CALL_UNREFIMAGE, 00252 GX_CALL_CREATEIMAGE, 00253 GX_CALL_CONVERTIMAGE, 00254 GX_CALL_ZOOMIMAGE, 00255 GX_CALL_ROTATEIMAGE, 00256 GX_CALL_MIRRORIMAGE, 00257 GX_CALL_LOADIMAGE, 00258 GX_CALL_LOADIMAGEA, 00259 GX_CALL_SAVEIMAGE, 00260 GX_CALL_SAVEIMAGEA, 00261 GX_CALL_LOADFROMMEM, 00262 GX_CALL_SAVETOMEM, 00263 GX_CALL_ISVALIDIMAGE, 00264 GX_CALL_DISPLAYIMAGE, 00265 GX_CALL_GETPIXELPTR, 00266 GX_CALL_IMGTOCLIPBOARD, 00267 GX_CALL_PASTEIMAGE, 00269 GX_CALL_LOADIMAGEFROMFILE, 00270 GX_CALL_LOADIMAGEFROMFILEA, 00271 GX_CALL_LOADIMAGEFROMMEM, 00272 GX_CALL_SAVEIMAGETOFILE, 00273 GX_CALL_SAVEIMAGETOFILEA, 00274 GX_CALL_SAVEIMAGETOMEM, 00276 GX_CALL_COPYIMAGE, 00277 GX_CALL_IMAGETOVARIANT, 00278 GX_CALL_IMAGEFROMVARIANT, 00280 GX_CALL_TESTIMAGEFILEFORMAT, 00281 GX_CALL_TESTIMAGEFILEFORMATA, 00282 GX_CALL_TESTIMAGEFILEFORMATMEM, 00284 GX_CALL_GETIMAGEFILEFORMATINFO, 00285 GX_CALL_SAVEIMAGETOFILE2, 00286 GX_CALL_SAVEIMAGETOMEM2, 00288 GX_CALL_TESTIMAGEFILEFORMATID, 00289 GX_CALL_TESTIMAGEFILEFORMATIDMEM, 00290 }; 00291 /******************************************************************************/ 00292 /* Parameter structure for the gx_getpixelsize() function. */ 00293 struct GX_PARM_GETPIXELSIZE { 00294 gxi32 format; 00295 gxi32 size; 00296 }; 00297 00298 /* Parameter structure for the gx_convertpixels() function. */ 00299 struct GX_PARM_CONVERTPIXELS { 00300 void *target; 00301 gxi32 tformat; 00302 gxi32 tsline; 00303 const void *source; 00304 gxi32 sformat; 00305 gxi32 ssline; 00306 gxi32 xsize; 00307 gxi32 ysize; 00308 }; 00309 00317 struct GX_PARM_FASTRECONVERT { 00318 void *pixels; 00319 gxi32 tformat; 00320 gxi32 sformat; 00321 gxi32 sline; 00322 gxi32 xsize; 00323 gxi32 ysize; 00324 }; 00325 00327 struct GX_PARM_ZOOMPIXELS { 00328 void *target; 00329 gxi32 tsline; 00330 gxi32 txsize; 00331 gxi32 tysize; 00332 const void *source; 00333 gxi32 ssline; 00334 gxi32 sxsize; 00335 gxi32 sysize; 00336 gxi32 format; 00337 gxi32 sx1_8; 00338 gxi32 sy1_8; 00339 gxi32 sx2_8; 00340 gxi32 sy2_8; 00341 }; 00342 00344 struct GX_PARM_ROTATEPIXELS { 00345 void *target; 00346 gxi32 tsline; 00347 gxi32 txsize; 00348 gxi32 tysize; 00349 const void *source; 00350 gxi32 ssline; 00351 gxi32 sxsize; 00352 gxi32 sysize; 00353 gxi32 format; 00354 gxi32 degree; 00355 }; 00356 00358 struct GX_PARM_MIRRORPIXELS { 00359 void *target; 00360 gxi32 tsline; 00361 gxi32 txsize; 00362 gxi32 tysize; 00363 const void *source; 00364 gxi32 ssline; 00365 gxi32 sxsize; 00366 gxi32 sysize; 00367 gxi32 format; 00368 gxi32 flags; 00369 }; 00370 00372 struct GX_PARM_CREATEIMAGE { 00373 gxIMAGE *pimage; 00374 gxi32 format; 00375 gxi32 xsize; 00376 gxi32 ysize; 00377 gxi32 sline; 00378 }; 00379 00381 struct GX_PARM_CONVERTIMAGE { 00382 gxIMAGE *pdest; 00383 gxIMAGE *psrc; 00384 gxi32 format; 00385 gxi32 xsize; 00386 gxi32 ysize; 00387 gxi32 sline; 00388 }; 00389 00391 struct GX_PARM_ZOOMIMAGE { 00392 gxIMAGE *pdest; 00393 gxi32 xsize; 00394 gxi32 ysize; 00395 gxi32 sline; 00396 gxIMAGE *psrc; 00397 gxi32 sx1_8; 00398 gxi32 sy1_8; 00399 gxi32 sx2_8; 00400 gxi32 sy2_8; 00401 }; 00402 00404 struct GX_PARM_ROTATEIMAGE { 00405 gxIMAGE *pdest; 00406 gxIMAGE *psrc; 00407 gxi32 degree; 00408 }; 00409 00411 struct GX_PARM_MIRRORIMAGE { 00412 gxIMAGE *pdest; 00413 gxIMAGE *psrc; 00414 gxi32 flags; 00415 }; 00416 00418 struct GX_PARM_LOADIMAGE { 00419 gxIMAGE *pimage; 00420 const wchar_t *filename; 00421 gxi32 format; 00422 }; 00423 00425 struct GX_PARM_LOADIMAGEA { 00426 gxIMAGE *pimage; 00427 const char *filename; 00428 gxi32 format; 00429 }; 00430 00432 struct GX_PARM_SAVEIMAGE { 00433 gxIMAGE *pimage; 00434 const wchar_t *filename; 00435 gxi32 fileformat; 00436 }; 00437 00439 struct GX_PARM_SAVEIMAGEA { 00440 gxIMAGE *pimage; 00441 const char *filename; 00442 gxi32 fileformat; 00443 }; 00444 00446 struct GX_PARM_LOADFROMMEM { 00447 gxIMAGE *pimage; 00448 const void *buffer; 00449 gxi32 buflen; 00450 gxi32 format; 00451 }; 00452 00454 struct GX_PARM_SAVETOMEM { 00455 gxIMAGE *pimage; 00456 void **buffer; 00457 gxi32 *buflen; 00458 gxi32 fileformat; 00459 }; 00460 00461 #if defined(WIN32) 00462 00463 struct GX_PARM_DISPLAYIMAGE { 00464 HDC hdc; 00465 gxi32 x; 00466 gxi32 y; 00467 gxi32 xsize; 00468 gxi32 ysize; 00469 gxIMAGE *pimage; 00470 }; 00471 #endif 00472 00474 struct GX_PARM_GETPIXELPTR { 00475 gxIMAGE *pimage; 00476 gxi32 x; 00477 gxi32 y; 00478 void *ptr; 00479 }; 00480 00482 struct GX_PARM_LOADIMAGEFROMFILE { 00483 gxIMAGE *pimage; 00484 const wchar_t *filename; 00485 gxi32 format; 00486 gxVARIANT properties; 00487 gxVARIANT comments; 00488 }; 00489 00491 struct GX_PARM_LOADIMAGEFROMFILEA { 00492 gxIMAGE *pimage; 00493 const char *filename; 00494 gxi32 format; 00495 gxVARIANT properties; 00496 gxVARIANT comments; 00497 }; 00498 00500 struct GX_PARM_SAVEIMAGETOFILE { 00501 gxIMAGE *pimage; 00502 const wchar_t *filename; 00503 gxi32 fileformat; 00504 gxVARIANT properties; 00505 gxVARIANT comments; 00506 }; 00507 00509 struct GX_PARM_SAVEIMAGETOFILEA { 00510 gxIMAGE *pimage; 00511 const char *filename; 00512 gxi32 fileformat; 00513 gxVARIANT properties; 00514 gxVARIANT comments; 00515 }; 00516 00518 struct GX_PARM_SAVEIMAGETOFILE2 { 00519 gxIMAGE *pimage; 00520 const wchar_t *filename; 00521 const wchar_t *fileformat; 00522 gxVARIANT properties; 00523 gxVARIANT comments; 00524 }; 00525 00527 struct GX_PARM_LOADIMAGEFROMMEM { 00528 gxIMAGE *pimage; 00529 const void *buffer; 00530 gxi32 buflen; 00531 gxi32 format; 00532 gxVARIANT properties; 00533 gxVARIANT comments; 00534 }; 00535 00537 struct GX_PARM_SAVEIMAGETOMEM { 00538 gxIMAGE *pimage; 00539 void **buffer; 00540 gxi32 *buflen; 00541 gxi32 fileformat; 00542 gxVARIANT properties; 00543 gxVARIANT comments; 00544 }; 00545 00547 struct GX_PARM_SAVEIMAGETOMEM2 { 00548 gxIMAGE *pimage; 00549 void **buffer; 00550 gxi32 *buflen; 00551 const wchar_t *fileformat; 00552 gxVARIANT properties; 00553 gxVARIANT comments; 00554 }; 00555 00557 struct GX_PARM_COPYIMAGE { 00558 gxIMAGE *target; 00559 gxIMAGE *source; 00560 }; 00561 00563 struct GX_PARM_IMAGETOVARIANT { 00564 gxIMAGE *pimage; 00565 int varid; 00566 gxVARIANT variant; 00567 }; 00568 00570 struct GX_PARM_IMAGEFROMVARIANT { 00571 gxIMAGE *pimage; 00572 gxVARIANT variant; 00573 }; 00574 00576 struct GX_PARM_TESTIMAGEFILEFORMAT { 00577 const wchar_t *filename; 00578 gxi32 fileformat; 00579 }; 00580 00582 struct GX_PARM_TESTIMAGEFILEFORMATA { 00583 const char *filename; 00584 gxi32 fileformat; 00585 }; 00586 00588 struct GX_PARM_TESTIMAGEFILEFORMATMEM { 00589 const void *buffer; 00590 gxi32 buflen; 00591 gxi32 fileformat; 00592 }; 00593 00595 struct GX_PARM_TESTIMAGEFILEFORMATID { 00596 const wchar_t *filename; 00597 wchar_t* formatid; 00598 gxi32 slen; 00599 }; 00600 00602 struct GX_PARM_TESTIMAGEFILEFORMATIDMEM { 00603 const void *buffer; 00604 gxi32 buflen; 00605 wchar_t* formatid; 00606 gxi32 slen; 00607 }; 00608 00609 #endif /* GX_SWIGIF GX_MANUAL )*/ 00610 00611 /******************************************************************************/ 00612 #if !defined(NO_GX_FUNCTIONS) && !defined(GX_SWIGIF) /*(*/ 00613 /******************************************************************************/ 00614 00615 /******************************************************************************/ 00623 inline gxi32 gx_getpixelsize(gxHANDLE handle, gxi32 *size, gxi32 format) { 00624 struct GX_PARM_GETPIXELSIZE ps; 00625 gxi32 ret; 00626 assert(size); 00627 ps.format = format; 00628 ret = gx_call(handle, GX_CALL_GETPIXELSIZE, &ps); 00629 if(ret) *size = ps.size; 00630 return ret; 00631 } 00632 00633 /******************************************************************************/ 00647 inline gxi32 gx_convertpixels(gxHANDLE handle, 00648 void *target, gxi32 tformat, gxi32 tsline, 00649 const void *source, gxi32 sformat, gxi32 ssline, 00650 gxi32 xsize, gxi32 ysize) { 00651 00652 struct GX_PARM_CONVERTPIXELS cp; 00653 cp.target = target; 00654 cp.tformat = tformat; 00655 cp.tsline = tsline; 00656 cp.source = source; 00657 cp.sformat = sformat; 00658 cp.ssline = ssline; 00659 cp.xsize = xsize; 00660 cp.ysize = ysize; 00661 return gx_call(handle, GX_CALL_CONVERTPIXELS, &cp); 00662 } 00663 00664 /******************************************************************************/ 00683 inline gxi32 gx_fastreconvert(gxHANDLE handle, 00684 void *pixels, gxi32 tformat, gxi32 sformat, 00685 gxi32 sline, gxi32 xsize, gxi32 ysize) { 00686 00687 struct GX_PARM_FASTRECONVERT fr; 00688 fr.pixels = pixels; 00689 fr.tformat = tformat; 00690 fr.sformat = sformat; 00691 fr.sline = sline; 00692 fr.xsize = xsize; 00693 fr.ysize = ysize; 00694 return gx_call(handle, GX_CALL_FASTRECONVERT, &fr); 00695 } 00696 00697 /******************************************************************************/ 00716 inline gxi32 gx_zoompixels(gxHANDLE handle, 00717 void *target, gxi32 tsline, gxi32 txsize, gxi32 tysize, 00718 const void *source, gxi32 ssline, gxi32 sxsize, gxi32 sysize, 00719 gxi32 format, 00720 gxi32 sx1_8 GX_DEFARG(0), gxi32 sy1_8 GX_DEFARG(0), 00721 gxi32 sx2_8 GX_DEFARG(0), gxi32 sy2_8 GX_DEFARG(0)) 00722 { 00723 00724 struct GX_PARM_ZOOMPIXELS zp; 00725 assert(target); 00726 assert(source); 00727 zp.target = target; 00728 zp.tsline = tsline; 00729 zp.txsize = txsize; 00730 zp.tysize = tysize; 00731 zp.source = (void *)source; 00732 zp.ssline = ssline; 00733 zp.sxsize = sxsize; 00734 zp.sysize = sysize; 00735 zp.format = format; 00736 zp.sx1_8 = sx1_8; 00737 zp.sy1_8 = sy1_8; 00738 zp.sx2_8 = sx2_8; 00739 zp.sy2_8 = sy2_8; 00740 return gx_call(handle, GX_CALL_ZOOMPIXELS, &zp); 00741 } 00742 00743 /******************************************************************************/ 00759 inline gxi32 gx_rotatepixels(gxHANDLE handle, 00760 void *target, gxi32 tsline, gxi32 txsize, gxi32 tysize, 00761 const void *source, gxi32 ssline, gxi32 sxsize, gxi32 sysize, 00762 gxi32 format, gxi32 degree) { 00763 00764 struct GX_PARM_ROTATEPIXELS rp; 00765 assert(target); 00766 assert(source); 00767 rp.target = target; 00768 rp.tsline = tsline; 00769 rp.txsize = txsize; 00770 rp.tysize = tysize; 00771 rp.source = source; 00772 rp.ssline = ssline; 00773 rp.sxsize = sxsize; 00774 rp.sysize = sysize; 00775 rp.format = format; 00776 rp.degree = degree; 00777 return gx_call(handle, GX_CALL_ROTATEPIXELS, &rp); 00778 } 00779 00780 /******************************************************************************/ 00797 inline gxi32 gx_mirrorpixels(gxHANDLE handle, 00798 void *target, gxi32 tsline, gxi32 txsize, gxi32 tysize, 00799 const void *source, gxi32 ssline, gxi32 sxsize, gxi32 sysize, 00800 gxi32 format, gxi32 flags) { 00801 00802 struct GX_PARM_MIRRORPIXELS mp; 00803 assert(target); 00804 assert(source); 00805 mp.target = target; 00806 mp.tsline = tsline; 00807 mp.txsize = txsize; 00808 mp.tysize = tysize; 00809 mp.source = source; 00810 mp.ssline = ssline; 00811 mp.sxsize = sxsize; 00812 mp.sysize = sysize; 00813 mp.format = format; 00814 mp.flags = flags; 00815 return gx_call(handle, GX_CALL_MIRRORPIXELS, &mp); 00816 } 00817 00818 #ifdef __cplusplus 00819 /******************************************************************************/ 00831 inline gxi32 gx_mirrorpixels(gxHANDLE handle, 00832 void *pixels, gxi32 sline, gxi32 xsize, gxi32 ysize, 00833 gxi32 format, gxi32 flags) { 00834 return gx_mirrorpixels(handle, pixels, sline, xsize, ysize, 00835 pixels, sline, xsize, ysize, 00836 format, flags); 00837 } 00838 #endif 00839 00840 /******************************************************************************/ 00844 /******************************************************************************/ 00845 00846 /******************************************************************************/ 00856 inline gxi32 gx_initimage(gxHANDLE handle, gxIMAGE *pimage) { 00857 assert(pimage); 00858 return gx_call(handle, GX_CALL_INITIMAGE, (void *)pimage); 00859 } 00860 00861 /******************************************************************************/ 00871 inline gxi32 gx_allocimage(gxHANDLE handle, gxIMAGE **pimage) { 00872 assert(pimage); 00873 return gx_call(handle, GX_CALL_ALLOCIMAGE, (void *)pimage); 00874 } 00875 00876 /******************************************************************************/ 00886 inline gxi32 gx_freeimage(gxHANDLE handle, gxIMAGE *pimage) { 00887 assert(pimage); 00888 return gx_call(handle, GX_CALL_FREEIMAGE, (void *)pimage); 00889 } 00890 00891 /******************************************************************************/ 00893 /******************************************************************************/ 00897 /******************************************************************************/ 00898 00899 /******************************************************************************/ 00909 inline gxi32 gx_refimage(gxHANDLE handle, gxIMAGE *pimage) { 00910 assert(pimage); 00911 return gx_call(handle, GX_CALL_REFIMAGE, (void *)pimage); 00912 } 00913 00914 /******************************************************************************/ 00924 inline gxi32 gx_unrefimage(gxHANDLE handle, gxIMAGE *pimage) { 00925 assert(pimage); 00926 return gx_call(handle, GX_CALL_UNREFIMAGE, (void *)pimage); 00927 } 00928 00929 /******************************************************************************/ 00931 /******************************************************************************/ 00935 /******************************************************************************/ 00936 00937 /******************************************************************************/ 00949 inline gxi32 gx_createimage(gxHANDLE handle, gxIMAGE* pimage, gxi32 format, 00950 gxi32 xsize, gxi32 ysize, gxi32 sline) { 00951 struct GX_PARM_CREATEIMAGE ci; 00952 assert(pimage); 00953 assert(xsize > 0); 00954 assert(ysize > 0); 00955 ci.pimage = pimage; 00956 ci.format = format; 00957 ci.xsize = xsize; 00958 ci.ysize = ysize; 00959 ci.sline = sline; 00960 return gx_call(handle, GX_CALL_CREATEIMAGE, (void *)&ci); 00961 } 00962 00963 /******************************************************************************/ 00978 inline gxi32 gx_convertimage(gxHANDLE handle, gxIMAGE* pdest, 00979 gxIMAGE* psrc, gxi32 format, gxi32 xsize, gxi32 ysize, gxi32 sline) { 00980 00981 struct GX_PARM_CONVERTIMAGE ci; 00982 assert(pdest); 00983 assert(psrc); 00984 assert(xsize > 0); 00985 assert(ysize > 0); 00986 ci.pdest = pdest; 00987 ci.psrc = psrc; 00988 ci.format = format; 00989 ci.xsize = xsize; 00990 ci.ysize = ysize; 00991 ci.sline = sline; 00992 return gx_call(handle, GX_CALL_CONVERTIMAGE, (void *)&ci); 00993 } 00994 00995 /******************************************************************************/ 01010 inline gxi32 gx_zoomimage(gxHANDLE handle, gxIMAGE *pdest, 01011 gxi32 xsize, gxi32 ysize, gxi32 sline, 01012 gxIMAGE *psrc, 01013 gxi32 sx1_8 GX_DEFARG(0), gxi32 sy1_8 GX_DEFARG(0), 01014 gxi32 sx2_8 GX_DEFARG(0), gxi32 sy2_8 GX_DEFARG(0)) { 01015 01016 struct GX_PARM_ZOOMIMAGE zi; 01017 assert(pdest); 01018 assert(psrc); 01019 assert(xsize > 0); 01020 assert(ysize > 0); 01021 zi.pdest = pdest; 01022 zi.xsize = xsize; 01023 zi.ysize = ysize; 01024 zi.sline = sline; 01025 zi.psrc = psrc; 01026 zi.sx1_8 = sx1_8; 01027 zi.sy1_8 = sy1_8; 01028 zi.sx2_8 = sx2_8; 01029 zi.sy2_8 = sy2_8; 01030 return gx_call(handle, GX_CALL_ZOOMIMAGE, (void *)&zi); 01031 } 01032 01033 /******************************************************************************/ 01042 inline gxi32 gx_rotateimage(gxHANDLE handle, gxIMAGE *pdest, 01043 gxIMAGE *psrc, gxi32 degree) { 01044 01045 struct GX_PARM_ROTATEIMAGE ri; 01046 assert(pdest); 01047 assert(psrc); 01048 ri.pdest = pdest; 01049 ri.psrc = psrc; 01050 ri.degree = degree; 01051 return gx_call(handle, GX_CALL_ROTATEIMAGE, &ri); 01052 } 01053 01054 /******************************************************************************/ 01064 inline gxi32 gx_mirrorimage(gxHANDLE handle, gxIMAGE *pdest, 01065 gxIMAGE *psrc, gxi32 flags) { 01066 01067 struct GX_PARM_MIRRORIMAGE mi; 01068 assert(pdest); 01069 assert(psrc); 01070 mi.pdest = pdest; 01071 mi.psrc = psrc; 01072 mi.flags = flags; 01073 return gx_call(handle, GX_CALL_MIRRORIMAGE, &mi); 01074 } 01075 01076 #ifdef __cplusplus 01077 /******************************************************************************/ 01085 inline gxi32 gx_mirrorimage(gxHANDLE handle, gxIMAGE *pimage, gxi32 flags) { 01086 return gx_mirrorimage(handle, pimage, pimage, flags); 01087 } 01088 #endif 01089 01090 /******************************************************************************/ 01114 inline gxi32 gx_loadimage(gxHANDLE handle, gxIMAGE* pimage, 01115 const wchar_t* filename, gxi32 pixelformat GX_DEFARG(GX_UNDEF)) { 01116 01117 struct GX_PARM_LOADIMAGE li; 01118 assert(pimage); 01119 assert(filename); 01120 li.pimage = pimage; 01121 li.filename = filename; 01122 li.format = pixelformat; 01123 return gx_call(handle, GX_CALL_LOADIMAGE, (void *)&li); 01124 } 01125 01126 /******************************************************************************/ 01150 inline gxi32 gx_loadimagea(gxHANDLE handle, gxIMAGE* pimage, 01151 const char* filename, gxi32 pixelformat GX_DEFARG(GX_UNDEF)) { 01152 struct GX_PARM_LOADIMAGEA li; 01153 assert(pimage); 01154 assert(filename); 01155 li.pimage = pimage; 01156 li.filename = filename; 01157 li.format = pixelformat; 01158 return gx_call(handle, GX_CALL_LOADIMAGEA, (void *)&li); 01159 } 01160 01161 #ifdef __cplusplus 01162 /******************************************************************************/ 01186 inline gxi32 gx_loadimage(gxHANDLE handle, gxIMAGE* pimage, 01187 const char* filename, gxi32 pixelformat GX_DEFARG(GX_UNDEF)) { 01188 01189 return gx_loadimagea(handle, pimage, filename, pixelformat); 01190 } 01191 #endif 01192 01193 /******************************************************************************/ 01202 inline gxi32 gx_saveimage(gxHANDLE handle, gxIMAGE* pimage, 01203 const wchar_t* filename, gxi32 fileformat) { 01204 01205 struct GX_PARM_SAVEIMAGE si; 01206 assert(pimage); 01207 assert(filename); 01208 si.pimage = pimage; 01209 si.filename = filename; 01210 si.fileformat = fileformat; 01211 return gx_call(handle, GX_CALL_SAVEIMAGE, (void *)&si); 01212 } 01213 01214 /******************************************************************************/ 01223 inline gxi32 gx_saveimagea(gxHANDLE handle, gxIMAGE* pimage, 01224 const char* filename, gxi32 fileformat) { 01225 01226 struct GX_PARM_SAVEIMAGEA si; 01227 assert(pimage); 01228 assert(filename); 01229 si.pimage = pimage; 01230 si.filename = filename; 01231 si.fileformat = fileformat; 01232 return gx_call(handle, GX_CALL_SAVEIMAGEA, (void *)&si); 01233 } 01234 01235 #ifdef __cplusplus 01236 /******************************************************************************/ 01245 inline gxi32 gx_saveimage(gxHANDLE handle, gxIMAGE *pimage, 01246 const char *filename, gxi32 fileformat) { 01247 01248 return gx_saveimagea(handle, pimage, filename, fileformat); 01249 } 01250 #endif 01251 01252 /******************************************************************************/ 01268 inline gxi32 gx_loadfrommem(gxHANDLE handle, gxIMAGE* pimage, 01269 const void *buffer, gxi32 buflen, gxi32 pixelformat GX_DEFARG(GX_UNDEF)) { 01270 struct GX_PARM_LOADFROMMEM lm; 01271 assert(pimage); 01272 assert(buffer); 01273 assert(buflen > 0); 01274 lm.pimage = pimage; 01275 lm.buffer = buffer; 01276 lm.buflen = buflen; 01277 lm.format = pixelformat; 01278 return gx_call(handle, GX_CALL_LOADFROMMEM, (void *)&lm); 01279 } 01280 01281 /******************************************************************************/ 01290 inline gxi32 gx_savetomem(gxHANDLE handle, gxIMAGE* pimage, 01291 void **buffer, gxi32 *buflen, gxi32 fileformat) { 01292 struct GX_PARM_SAVETOMEM sm; 01293 assert(pimage); 01294 assert(buffer); 01295 assert(buflen); 01296 assert(*buflen >= 0); 01297 sm.pimage = pimage; 01298 sm.buffer = buffer; 01299 sm.buflen = buflen; 01300 sm.fileformat = fileformat; 01301 return gx_call(handle, GX_CALL_SAVETOMEM, (void *)&sm); 01302 } 01303 01304 /******************************************************************************/ 01309 inline gxi32 gx_isvalidimage(gxHANDLE handle, const gxIMAGE *pimage) { 01310 return gx_call(handle, GX_CALL_ISVALIDIMAGE, (void *)pimage); 01311 } 01312 01313 /******************************************************************************/ 01314 #ifdef WIN32 /*(*/ 01315 01325 inline gxi32 gx_displayimage(gxHANDLE handle, HDC hdc, gxi32 x, gxi32 y, 01326 gxi32 xsize, gxi32 ysize, gxIMAGE *pimage) { 01327 01328 struct GX_PARM_DISPLAYIMAGE di; 01329 assert(pimage); 01330 di.hdc = hdc; 01331 di.x = x; 01332 di.y = y; 01333 di.xsize = xsize; 01334 di.ysize = ysize; 01335 di.pimage = pimage; 01336 return gx_call(handle, GX_CALL_DISPLAYIMAGE, (void *)&di); 01337 } 01338 01339 /******************************************************************************/ 01345 inline gxi32 gx_imgtoclipboard(gxHANDLE handle, gxIMAGE *pimage) { 01346 assert(pimage); 01347 return gx_call(handle, GX_CALL_IMGTOCLIPBOARD, (void *)pimage); 01348 } 01349 01350 /******************************************************************************/ 01356 inline gxi32 gx_pasteimage(gxHANDLE handle, gxIMAGE *pimage) { 01357 assert(pimage); 01358 return gx_call(handle, GX_CALL_PASTEIMAGE, (void *)pimage); 01359 } 01360 #endif /*)*/ 01361 01362 /******************************************************************************/ 01364 /******************************************************************************/ 01368 /******************************************************************************/ 01369 01370 /******************************************************************************/ 01377 inline gxi32 gx_copyimage(gxHANDLE handle, gxIMAGE *target, gxIMAGE *source) { 01378 struct GX_PARM_COPYIMAGE cp; 01379 assert(target); 01380 assert(source); 01381 cp.target = target; 01382 cp.source = source; 01383 return gx_call(handle, GX_CALL_COPYIMAGE, (void *)&cp); 01384 } 01385 01386 /******************************************************************************/ 01394 inline gxi32 gx_testimagefileformat(gxHANDLE handle, const wchar_t *filename, 01395 gxi32 *fileformat) { 01396 01397 struct GX_PARM_TESTIMAGEFILEFORMAT ti; 01398 assert(fileformat); 01399 ti.filename = filename; 01400 if(!gx_call(handle, GX_CALL_TESTIMAGEFILEFORMAT, (void *)&ti)) return false; 01401 *fileformat = ti.fileformat; 01402 return true; 01403 } 01404 01405 /******************************************************************************/ 01413 inline gxi32 gx_testimagefileformata(gxHANDLE handle, const char *filename, 01414 gxi32 *fileformat) { 01415 01416 struct GX_PARM_TESTIMAGEFILEFORMATA ti; 01417 assert(fileformat); 01418 ti.filename = filename; 01419 if(!gx_call(handle, GX_CALL_TESTIMAGEFILEFORMATA, (void *)&ti)) return false; 01420 *fileformat = ti.fileformat; 01421 return true; 01422 } 01423 01424 #ifdef __cplusplus 01425 /******************************************************************************/ 01433 inline gxi32 gx_testimagefileformat(gxHANDLE handle, const char *filename, 01434 gxi32 *fileformat) { 01435 return gx_testimagefileformata(handle, filename, fileformat); 01436 } 01437 #endif 01438 01439 /******************************************************************************/ 01448 inline gxi32 gx_testimagefileformatmem(gxHANDLE handle, const void *buffer, gxi32 buflen, 01449 gxi32 *fileformat) { 01450 01451 struct GX_PARM_TESTIMAGEFILEFORMATMEM ti; 01452 assert(fileformat); 01453 ti.buffer = buffer; 01454 ti.buflen = buflen; 01455 if(!gx_call(handle, GX_CALL_TESTIMAGEFILEFORMATMEM, (void *)&ti)) return false; 01456 *fileformat = ti.fileformat; 01457 return true; 01458 } 01459 01460 /******************************************************************************/ 01469 inline gxi32 gx_testimagefileformatid(gxHANDLE handle, const wchar_t *filename, 01470 wchar_t *formatid, gxi32 slen) { 01471 01472 struct GX_PARM_TESTIMAGEFILEFORMATID ti; 01473 assert(formatid); 01474 ti.filename = filename; 01475 ti.formatid = formatid; 01476 ti.slen = slen; 01477 if(!gx_call(handle, GX_CALL_TESTIMAGEFILEFORMATID, (void *)&ti)) return false; 01478 return true; 01479 } 01480 01481 /******************************************************************************/ 01491 inline gxi32 gx_testimagefileformatidmem(gxHANDLE handle, const void *buffer, gxi32 buflen, 01492 wchar_t *formatid, gxi32 slen) { 01493 01494 struct GX_PARM_TESTIMAGEFILEFORMATIDMEM ti; 01495 assert(formatid); 01496 ti.buffer = buffer; 01497 ti.buflen = buflen; 01498 ti.formatid = formatid; 01499 ti.slen = slen; 01500 if(!gx_call(handle, GX_CALL_TESTIMAGEFILEFORMATIDMEM, (void *)&ti)) return false; 01501 return true; 01502 } 01503 01504 #ifdef __cplusplus 01505 /******************************************************************************/ 01514 inline gxi32 gx_testimagefileformat(gxHANDLE handle, const void *buffer, gxi32 buflen, 01515 gxi32 *fileformat) { 01516 return gx_testimagefileformatmem(handle, buffer, buflen, fileformat); 01517 } 01518 #endif 01519 01520 /******************************************************************************/ 01522 /******************************************************************************/ 01526 /******************************************************************************/ 01527 01528 /******************************************************************************/ 01536 inline gxi32 gx_imagetovariant(gxHANDLE handle, gxIMAGE *source, gxi32 varid, gxVARIANT *target) { 01537 struct GX_PARM_IMAGETOVARIANT itv; 01538 gxi32 ret; 01539 assert(target); 01540 assert(source); 01541 itv.pimage = source; 01542 itv.varid = varid; 01543 ret = gx_call(handle, GX_CALL_IMAGETOVARIANT, &itv); 01544 if(ret && target) *target = itv.variant; 01545 return ret; 01546 } 01547 01548 /******************************************************************************/ 01555 inline gxi32 gx_imagefromvariant(gxHANDLE handle, gxIMAGE **target, gxVARIANT source) { 01556 struct GX_PARM_IMAGEFROMVARIANT ifv; 01557 gxi32 ret; 01558 assert(target); 01559 assert(source); 01560 ifv.variant = source; 01561 ret = gx_call(handle, GX_CALL_IMAGEFROMVARIANT, &ifv); 01562 if(ret && target) *target = ifv.pimage; 01563 return ret; 01564 } 01565 01566 /******************************************************************************/ 01568 /******************************************************************************/ 01569 01570 /******************************************************************************/ 01578 inline void *gx_getpixelptr(gxHANDLE handle, gxIMAGE *pimage, gxi32 x, gxi32 y) { 01579 struct GX_PARM_GETPIXELPTR gp; 01580 assert(pimage); 01581 gp.pimage = pimage; 01582 gp.x = x; 01583 gp.y = y; 01584 if(!gx_call(handle, GX_CALL_GETPIXELPTR, (void *)&gp)) return (void *)0; 01585 return gp.ptr; 01586 } 01587 01588 /******************************************************************************/ 01589 #ifdef __cplusplus /*(*/ 01590 /******************************************************************************/ 01596 inline gxi32 gx_getpixelsize(gxi32 *size, gxi32 format) { 01597 return gx_getpixelsize(gx_direct(GX_CALL_GROUP_GX_IMAGE), size, format); 01598 } 01599 01600 /******************************************************************************/ 01612 inline gxi32 gx_convertpixels(void *target, gxi32 tformat, gxi32 tsline, 01613 const void *source, gxi32 sformat, gxi32 ssline, 01614 gxi32 xsize, gxi32 ysize) { 01615 01616 return gx_convertpixels(gx_direct(GX_CALL_GROUP_GX_IMAGE), 01617 target, tformat, tsline, 01618 source, sformat, ssline, xsize, ysize); 01619 } 01620 01621 /******************************************************************************/ 01639 inline gxi32 gx_fastreconvert(void *pixels, gxi32 tformat, gxi32 sformat, 01640 gxi32 sline, gxi32 xsize, gxi32 ysize) { 01641 01642 return gx_fastreconvert(gx_direct(GX_CALL_GROUP_GX_IMAGE), 01643 pixels, tformat, sformat, 01644 sline, xsize, ysize); 01645 } 01646 01647 /******************************************************************************/ 01665 inline gxi32 gx_zoompixels(void *target, gxi32 tsline, gxi32 txsize, gxi32 tysize, 01666 const void *source, gxi32 ssline, gxi32 sxsize, gxi32 sysize, 01667 gxi32 format, 01668 gxi32 sx1_8 = 0, gxi32 sy1_8 = 0, 01669 gxi32 sx2_8 = 0, gxi32 sy2_8 = 0) { 01670 01671 return gx_zoompixels(gx_direct(GX_CALL_GROUP_GX_IMAGE), 01672 target, tsline, txsize, tysize, 01673 source, ssline, sxsize, sysize, format, 01674 sx1_8, sy1_8, sx2_8, sy2_8); 01675 } 01676 01677 /******************************************************************************/ 01692 inline gxi32 gx_rotatepixels(void *target, gxi32 tsline, gxi32 txsize, gxi32 tysize, 01693 const void *source, gxi32 ssline, gxi32 sxsize, gxi32 sysize, 01694 gxi32 format, gxi32 degree) { 01695 01696 return gx_rotatepixels(gx_direct(GX_CALL_GROUP_GX_IMAGE), 01697 target, tsline, txsize, tysize, 01698 source, ssline, sxsize, sysize, 01699 format, degree); 01700 } 01701 01702 /******************************************************************************/ 01718 inline gxi32 gx_mirrorpixels(void *target, gxi32 tsline, gxi32 txsize, gxi32 tysize, 01719 const void *source, gxi32 ssline, gxi32 sxsize, gxi32 sysize, 01720 gxi32 format, gxi32 flags) { 01721 01722 return gx_mirrorpixels(gx_direct(GX_CALL_GROUP_GX_IMAGE), 01723 target, tsline, txsize, tysize, 01724 source, ssline, sxsize, sysize, 01725 format, flags); 01726 } 01727 01728 /******************************************************************************/ 01739 inline gxi32 gx_mirrorpixels(void *pixels, gxi32 sline, gxi32 xsize, gxi32 ysize, 01740 gxi32 format, gxi32 flags) { 01741 01742 return gx_mirrorpixels(pixels, sline, xsize, ysize, 01743 pixels, sline, xsize, ysize, 01744 format, flags); 01745 } 01746 01747 /******************************************************************************/ 01751 /******************************************************************************/ 01752 01753 /******************************************************************************/ 01762 inline gxi32 gx_initimage(gxIMAGE *pimage) { 01763 return gx_initimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage); 01764 } 01765 01766 /******************************************************************************/ 01775 inline gxi32 gx_allocimage(gxIMAGE **pimage) { 01776 return gx_allocimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage); 01777 } 01778 01779 /******************************************************************************/ 01788 inline gxi32 gx_freeimage(gxIMAGE *pimage) { 01789 return gx_freeimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage); 01790 } 01791 01792 /******************************************************************************/ 01794 /******************************************************************************/ 01798 /******************************************************************************/ 01799 01800 /******************************************************************************/ 01809 inline gxi32 gx_refimage(gxIMAGE *pimage) { 01810 return gx_refimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage); 01811 } 01812 01813 /******************************************************************************/ 01822 inline gxi32 gx_unrefimage(gxIMAGE *pimage) { 01823 return gx_unrefimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage); 01824 } 01825 01826 /******************************************************************************/ 01828 /******************************************************************************/ 01832 /******************************************************************************/ 01833 01834 /******************************************************************************/ 01845 inline gxi32 gx_createimage(gxIMAGE* pimage, gxi32 format, 01846 gxi32 xsize, gxi32 ysize, gxi32 sline) { 01847 return gx_createimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), 01848 pimage, format, xsize, ysize, sline); 01849 } 01850 01851 /******************************************************************************/ 01864 inline gxi32 gx_convertimage(gxIMAGE* pdest, gxIMAGE* psrc, 01865 gxi32 format, gxi32 xsize, gxi32 ysize, gxi32 sline) { 01866 01867 return gx_convertimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), 01868 pdest, psrc, format, xsize, ysize, sline); 01869 } 01870 01871 /******************************************************************************/ 01885 inline gxi32 gx_zoomimage(gxIMAGE *pdest, 01886 gxi32 xsize, gxi32 ysize, gxi32 sline, 01887 gxIMAGE *psrc, 01888 gxi32 sx1_8 = 0, gxi32 sy1_8 = 0, 01889 gxi32 sx2_8 = 0, gxi32 sy2_8 = 0) { 01890 01891 return gx_zoomimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), 01892 pdest, xsize, ysize, sline, 01893 psrc, sx1_8, sy1_8, sx2_8, sy2_8); 01894 } 01895 01896 /******************************************************************************/ 01904 inline gxi32 gx_rotateimage(gxIMAGE *pdest, gxIMAGE *psrc, gxi32 degree) { 01905 return gx_rotateimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pdest, psrc, degree); 01906 } 01907 01908 /******************************************************************************/ 01917 inline gxi32 gx_mirrorimage(gxIMAGE *pdest, gxIMAGE *psrc, gxi32 flags) { 01918 return gx_mirrorimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pdest, psrc, flags); 01919 } 01920 01921 /******************************************************************************/ 01928 inline gxi32 gx_mirrorimage(gxIMAGE *pimage, gxi32 flags) { 01929 return gx_mirrorimage(pimage, pimage, flags); 01930 } 01931 01932 /******************************************************************************/ 01955 inline gxi32 gx_loadimage(gxIMAGE* pimage, const wchar_t* filename, 01956 gxi32 pixelformat GX_DEFARG(GX_UNDEF)) { 01957 01958 return gx_loadimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage, 01959 filename, pixelformat); 01960 } 01961 01962 /******************************************************************************/ 01985 inline gxi32 gx_loadimage(gxIMAGE* pimage, const char* filename, 01986 gxi32 pixelformat GX_DEFARG(GX_UNDEF)) { 01987 01988 return gx_loadimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage, 01989 filename, pixelformat); 01990 } 01991 01992 /******************************************************************************/ 02000 inline gxi32 gx_saveimage(gxIMAGE* pimage, 02001 const wchar_t* filename, gxi32 fileformat) { 02002 02003 return gx_saveimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage, filename, fileformat); 02004 } 02005 02006 /******************************************************************************/ 02014 inline gxi32 gx_saveimage(gxIMAGE* pimage, 02015 const char* filename, gxi32 fileformat) { 02016 02017 return gx_saveimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage, filename, fileformat); 02018 } 02019 02020 /******************************************************************************/ 02034 inline gxi32 gx_loadfrommem(gxIMAGE* pimage, 02035 const void *buffer, gxi32 buflen, gxi32 pixelformat GX_DEFARG(GX_UNDEF)) { 02036 02037 return gx_loadfrommem(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage, buffer, 02038 buflen, pixelformat); 02039 } 02040 02041 /******************************************************************************/ 02049 inline gxi32 gx_savetomem(gxIMAGE* pimage, 02050 void **buffer, gxi32 *buflen, gxi32 fileformat) { 02051 02052 return gx_savetomem(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage, buffer, buflen, fileformat); 02053 } 02054 02055 /******************************************************************************/ 02059 inline gxi32 gx_isvalidimage(const gxIMAGE *pimage) { 02060 02061 return gx_isvalidimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage); 02062 } 02063 02064 /******************************************************************************/ 02065 #ifdef WIN32 /*(*/ 02066 02075 inline gxi32 gx_displayimage(HDC hdc, gxi32 x, gxi32 y, 02076 gxi32 xsize, gxi32 ysize, gxIMAGE *pimage) { 02077 02078 return gx_displayimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), hdc, x, y, xsize, ysize, pimage); 02079 } 02080 02081 /******************************************************************************/ 02086 inline gxi32 gx_imgtoclipboard(gxIMAGE *pimage) { 02087 assert(pimage); 02088 return gx_call(gx_direct(GX_CALL_GROUP_GX_IMAGE), GX_CALL_IMGTOCLIPBOARD, (void *)pimage); 02089 } 02090 02091 /******************************************************************************/ 02096 inline gxi32 gx_pasteimage(gxIMAGE *pimage) { 02097 assert(pimage); 02098 return gx_call(gx_direct(GX_CALL_GROUP_GX_IMAGE), GX_CALL_PASTEIMAGE, (void *)pimage); 02099 } 02100 #endif /*)*/ 02101 02102 /******************************************************************************/ 02108 inline gxi32 gx_copyimage(gxIMAGE *target, gxIMAGE *source) { 02109 return gx_copyimage(gx_direct(GX_CALL_GROUP_GX_IMAGE), target, source); 02110 } 02111 02112 /******************************************************************************/ 02114 /******************************************************************************/ 02118 /******************************************************************************/ 02119 02120 /******************************************************************************/ 02127 inline gxi32 gx_imagetovariant(gxIMAGE *source, gxi32 varid, gxVARIANT *target) { 02128 return gx_imagetovariant(gx_direct(GX_CALL_GROUP_GX_IMAGE), source, varid, target); 02129 } 02130 02131 /******************************************************************************/ 02137 inline gxi32 gx_imagefromvariant(gxIMAGE **target, gxVARIANT source) { 02138 return gx_imagefromvariant(gx_direct(GX_CALL_GROUP_GX_IMAGE), target, source); 02139 } 02140 02141 /******************************************************************************/ 02143 /******************************************************************************/ 02147 /******************************************************************************/ 02148 02149 /******************************************************************************/ 02174 inline gxi32 gx_loadimagefromfile(gxIMAGE* pimage, const wchar_t* filename, 02175 gxi32 pixelformat GX_DEFARG(GX_UNDEF), 02176 gxVARIANT properties GX_DEFARG(0), 02177 gxVARIANT comments GX_DEFARG(0)) { 02178 02179 struct GX_PARM_LOADIMAGEFROMFILE li; 02180 assert(pimage); 02181 assert(filename); 02182 li.pimage = pimage; 02183 li.filename = filename; 02184 li.format = pixelformat; 02185 li.properties = properties; 02186 li.comments = comments; 02187 return gx_call(gx_direct(GX_CALL_GROUP_GX_IMAGE), GX_CALL_LOADIMAGEFROMFILE, (void *)&li); 02188 } 02189 02190 /******************************************************************************/ 02215 inline gxi32 gx_loadimagefromfile(gxIMAGE* pimage, const char* filename, 02216 gxi32 pixelformat GX_DEFARG(GX_UNDEF), 02217 gxVARIANT properties GX_DEFARG(0), 02218 gxVARIANT comments GX_DEFARG(0)) { 02219 02220 struct GX_PARM_LOADIMAGEFROMFILEA li; 02221 assert(pimage); 02222 assert(filename); 02223 li.pimage = pimage; 02224 li.filename = filename; 02225 li.format = pixelformat; 02226 li.properties = properties; 02227 li.comments = comments; 02228 return gx_call(gx_direct(GX_CALL_GROUP_GX_IMAGE), GX_CALL_LOADIMAGEFROMFILEA, (void *)&li); 02229 } 02230 02231 /******************************************************************************/ 02241 inline gxi32 gx_saveimagetofile(gxIMAGE* pimage, 02242 const wchar_t* filename, gxi32 fileformat, 02243 gxVARIANT properties GX_DEFARG(0), 02244 gxVARIANT comments GX_DEFARG(0)) { 02245 02246 struct GX_PARM_SAVEIMAGETOFILE si; 02247 assert(pimage); 02248 assert(filename); 02249 si.pimage = pimage; 02250 si.filename = filename; 02251 si.fileformat = fileformat; 02252 si.properties = properties; 02253 si.comments = comments; 02254 return gx_call(gx_direct(GX_CALL_GROUP_GX_IMAGE), GX_CALL_SAVEIMAGETOFILE, (void *)&si); 02255 } 02256 02257 /******************************************************************************/ 02267 inline gxi32 gx_saveimagetofile(gxIMAGE* pimage, 02268 const char* filename, gxi32 fileformat, 02269 gxVARIANT properties GX_DEFARG(0), 02270 gxVARIANT comments GX_DEFARG(0)) { 02271 02272 struct GX_PARM_SAVEIMAGETOFILEA si; 02273 assert(pimage); 02274 assert(filename); 02275 si.pimage = pimage; 02276 si.filename = filename; 02277 si.fileformat = fileformat; 02278 si.properties = properties; 02279 si.comments = comments; 02280 return gx_call(gx_direct(GX_CALL_GROUP_GX_IMAGE), GX_CALL_SAVEIMAGETOFILEA, (void *)&si); 02281 } 02282 02283 /******************************************************************************/ 02294 inline gxi32 gx_saveimagetofile2(gxHANDLE handle, gxIMAGE* pimage, 02295 const wchar_t* filename, const wchar_t* fileformat, 02296 gxVARIANT properties GX_DEFARG(0), 02297 gxVARIANT comments GX_DEFARG(0)) { 02298 02299 struct GX_PARM_SAVEIMAGETOFILE2 si; 02300 assert(pimage); 02301 assert(filename); 02302 si.pimage = pimage; 02303 si.filename = filename; 02304 si.fileformat = fileformat; 02305 si.properties = properties; 02306 si.comments = comments; 02307 return gx_call(handle, GX_CALL_SAVEIMAGETOFILE2, (void *)&si); 02308 } 02309 02310 /******************************************************************************/ 02327 inline gxi32 gx_loadimagefrommem(gxIMAGE* pimage, 02328 const void *buffer, gxi32 buflen, gxi32 pixelformat GX_DEFARG(GX_UNDEF), 02329 gxVARIANT properties GX_DEFARG(0), 02330 gxVARIANT comments GX_DEFARG(0)) { 02331 02332 struct GX_PARM_LOADIMAGEFROMMEM li; 02333 assert(pimage); 02334 li.pimage = pimage; 02335 li.buffer = buffer; 02336 li.buflen = buflen; 02337 li.format = pixelformat; 02338 li.properties = properties; 02339 li.comments = comments; 02340 return gx_call(gx_direct(GX_CALL_GROUP_GX_IMAGE), GX_CALL_LOADIMAGEFROMMEM, (void *)&li); 02341 } 02342 02343 /******************************************************************************/ 02354 inline gxi32 gx_saveimagetomem(gxIMAGE* pimage, 02355 void **buffer, gxi32 *buflen, gxi32 fileformat, 02356 gxVARIANT properties GX_DEFARG(0), 02357 gxVARIANT comments GX_DEFARG(0)) { 02358 02359 struct GX_PARM_SAVEIMAGETOMEM si; 02360 assert(pimage); 02361 si.pimage = pimage; 02362 si.buffer = buffer; 02363 si.buflen = buflen; 02364 si.fileformat = fileformat; 02365 si.properties = properties; 02366 si.comments = comments; 02367 return gx_call(gx_direct(GX_CALL_GROUP_GX_IMAGE), GX_CALL_SAVEIMAGETOMEM, (void *)&si); 02368 } 02369 02370 /******************************************************************************/ 02382 inline gxi32 gx_saveimagetomem2(gxHANDLE handle, gxIMAGE* pimage, 02383 void **buffer, gxi32 *buflen, wchar_t* fileformat, 02384 gxVARIANT properties GX_DEFARG(0), 02385 gxVARIANT comments GX_DEFARG(0)) { 02386 02387 struct GX_PARM_SAVEIMAGETOMEM2 si; 02388 assert(pimage); 02389 si.pimage = pimage; 02390 si.buffer = buffer; 02391 si.buflen = buflen; 02392 si.fileformat = fileformat; 02393 si.properties = properties; 02394 si.comments = comments; 02395 return gx_call(handle, GX_CALL_SAVEIMAGETOMEM2, (void *)&si); 02396 } 02397 02398 /******************************************************************************/ 02405 inline gxi32 gx_testimagefileformat(const wchar_t *filename, gxi32 *fileformat) { 02406 02407 return gx_testimagefileformat(gx_direct(GX_CALL_GROUP_GX_IMAGE), filename, fileformat); 02408 } 02409 02410 /******************************************************************************/ 02417 inline gxi32 gx_testimagefileformat(const char *filename, gxi32 *fileformat) { 02418 02419 return gx_testimagefileformat(gx_direct(GX_CALL_GROUP_GX_IMAGE), filename, fileformat); 02420 } 02421 02422 /******************************************************************************/ 02430 inline gxi32 gx_testimagefileformat(const void *buffer, gxi32 buflen, gxi32 *fileformat) { 02431 02432 return gx_testimagefileformat(gx_direct(GX_CALL_GROUP_GX_IMAGE), buffer, buflen, fileformat); 02433 } 02434 02435 /******************************************************************************/ 02437 /******************************************************************************/ 02438 02439 /******************************************************************************/ 02446 inline void *gx_getpixelptr(gxIMAGE *pimage, gxi32 x, gxi32 y) { 02447 return gx_getpixelptr(gx_direct(GX_CALL_GROUP_GX_IMAGE), pimage, x, y); 02448 } 02449 02450 /******************************************************************************/ 02451 #endif /*)*/ 02452 #endif /*)*/ 02453 02454 #ifdef GX_DOTNET 02455 #pragma managed 02456 #endif 02457 02458 /******************************************************************************/ 02459 #if !defined(NO_GX_CLASSES) /*(*/ 02460 02461 #ifndef GX_EXT_MODULE /*(*/ 02462 02463 /******************************************************************************/ 02467 GX_CLASS gxImageData 02468 #ifdef GX_DOTNET 02469 : public System::IDisposable 02470 #endif 02471 { 02472 02473 #if !defined(GX_SWIGIF) /*(*/ 02474 02475 #if !defined(GX_DOTNET) && !defined(GX_MANUAL) 02476 public: 02477 GX_INDIRECTION_NOGC(gxIMAGE) _image; 02478 #endif 02479 02480 #if defined(GX_DOTNET) 02481 #if !defined(GX_MANUAL) 02482 private: 02483 GX_INDIRECTION_NOGC(gxIMAGE) _image; /* Pointer to the allocated gxIMAGE structure. */ 02484 #endif 02485 02486 public: 02492 inline gxOutPtr _get_image(void) GX_CONST { 02493 return GX_PUTPTR(_image); 02494 } 02500 inline void _set_image(gxInPtr ptr) { 02501 _image = (GX_INDIRECTION_NOGC(gxIMAGE))ptr.ToPointer(); 02502 } 02503 #endif 02504 02505 #endif /*)*/ 02506 02507 public: 02509 inline gxImageData() { 02510 _image = (GX_INDIRECTION_NOGC(gxIMAGE))GX_NULLPTR; 02511 } 02513 inline ~gxImageData() gxFuncThrowsError { 02514 _Dispose(); 02515 } 02516 02517 #ifdef GX_DOTNET_20 02518 inline !gxImageData() gxFuncThrowsError { 02519 _Dispose(); 02520 } 02521 #else 02522 02523 inline void Dispose(void) gxFuncThrowsError { 02524 #ifdef GX_DOTNET 02525 System::GC::SuppressFinalize(this);//do not call it from a destructor explicitly! 02526 #endif 02527 _Dispose(); 02529 } 02530 #endif 02531 02532 private: 02533 inline void _Dispose(void) { 02534 gxassert(!_image || (_image->ref == 0)); 02535 } 02536 public: 02537 02538 02541 inline gxi32 ref(void) GX_CONST gxFuncThrowsError { 02542 gxassert(_image); 02543 return _image->ref; 02544 } 02545 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 02546 02548 inline void *image(void) GX_CONST gxFuncThrowsError { 02549 gxassert(_image); 02550 return _image->image; 02551 } 02552 #endif 02553 02555 inline gxi32 simage(void) GX_CONST gxFuncThrowsError { 02556 gxassert(_image); 02557 return _image->simage; 02558 } 02561 inline gxi32 format(void) GX_CONST gxFuncThrowsError { 02562 gxassert(_image); 02563 return _image->format; 02564 } 02567 inline gxi32 xsize(void) GX_CONST gxFuncThrowsError { 02568 gxassert(_image); 02569 return _image->xsize; 02570 } 02573 inline gxi32 ysize(void) GX_CONST gxFuncThrowsError { 02574 gxassert(_image); 02575 return _image->ysize; 02576 } 02579 inline gxi32 sline(void) GX_CONST gxFuncThrowsError { 02580 gxassert(_image); 02581 return _image->sline; 02582 } 02585 inline gxi32 xres(void) GX_CONST gxFuncThrowsError { 02586 gxassert(_image); 02587 return _image->xres; 02588 } 02591 inline gxi32 yres(void) GX_CONST gxFuncThrowsError { 02592 gxassert(_image); 02593 return _image->yres; 02594 } 02598 inline void xres(gxi32 _xres) gxFuncThrowsError { 02599 gxassert(_image); 02600 _image->xres = _xres; 02601 } 02605 inline void yres(gxi32 _yres) gxFuncThrowsError { 02606 gxassert(_image); 02607 _image->yres = _yres; 02608 } 02609 02612 inline gxi32 GetRef(void) GX_CONST gxFuncThrowsError { 02613 return ref(); 02614 } 02615 02618 #if defined(GX_DOTNET) 02619 inline gxOutData GetPixels(void) GX_CONST gxFuncThrowsError { 02620 return GX_PUTDATA(_image->image, _image->simage); 02621 } 02622 #elif defined(GX_SWIG) 02623 inline gxOutData GetPixels(void) GX_CONST gxFuncThrowsError { 02624 return GX_PUTDATA(image(), simage()); 02625 } 02626 #else 02627 inline void *GetPixels(void) GX_CONST gxFuncThrowsError { 02628 return image(); 02629 } 02630 #endif 02631 02634 inline gxi32 GetSImage(void) GX_CONST gxFuncThrowsError { 02635 return simage(); 02636 } 02639 inline gxi32 GetPixelFormat(void) GX_CONST gxFuncThrowsError { 02640 return format(); 02641 } 02644 inline gxi32 GetXSize(void) GX_CONST gxFuncThrowsError { 02645 return xsize(); 02646 } 02649 inline gxi32 GetYSize(void) GX_CONST gxFuncThrowsError { 02650 return ysize(); 02651 } 02654 inline gxi32 GetSLine(void) GX_CONST gxFuncThrowsError { 02655 return sline(); 02656 } 02659 inline gxi32 GetXRes(void) GX_CONST gxFuncThrowsError { 02660 return xres(); 02661 } 02664 inline gxi32 GetYRes(void) GX_CONST gxFuncThrowsError { 02665 return yres(); 02666 } 02671 inline bool SetXRes(gxi32 _xres) gxFuncThrowsError { 02672 xres(_xres); 02673 return true; 02674 } 02679 inline bool SetYRes(gxi32 _yres) gxFuncThrowsError { 02680 yres(_yres); 02681 return true; 02682 } 02683 02684 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 02685 02687 inline operator gxIMAGE *() GX_CONST { 02688 return _image; 02689 } 02692 inline operator gxIMAGE &() GX_CONST gxFuncThrowsError { 02693 gxassert(_image); 02694 return *_image; 02695 } 02696 #endif 02697 }; 02698 02699 /******************************************************************************/ 02701 GX_CLASS gxImageHandler : public gxHandle 02702 { 02703 public: 02705 inline gxImageHandler() gxFuncThrowsError { 02706 #ifndef GX_DOTNET 02707 if(!gx_openmodule(this, L"gximage", L"default")) gxthrow; 02708 #else 02709 GX_GETHANDLE(h); 02710 if(!gx_openmodule(&h, L"gximage", L"default")) gxthrow; 02711 _set_handle(h.handle); 02712 #endif 02713 } 02714 02715 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 02716 02719 inline gxImageHandler(const gxHANDLE *src) gxFuncThrowsError : gxHandle() { 02720 if(src) { 02721 handle = src->handle; 02722 if(!gx_refhandle(*this)) gxthrow; 02723 } 02724 } 02728 inline gxImageHandler(const gxHANDLE &src) gxFuncThrowsError : gxHandle() { 02729 handle = src.handle; 02730 if(!gx_refhandle(*this)) gxthrow; 02731 } 02732 02737 inline gxImageHandler(const wchar_t *propname, 02738 const wchar_t *modname = (const wchar_t *)0) gxFuncThrowsError { 02739 02740 if(!gx_openmodule(this, modname ? modname : L"gximage", propname)) gxthrow; 02741 } 02742 02747 inline gxImageHandler(const char *propname, 02748 const char *modname = (const char *)0) gxFuncThrowsError { 02749 02750 if(!gx_openmodulea(this, modname ? modname : "gximage", propname)) gxthrow; 02751 } 02752 #endif /* GX_SWIGIF GX_DOTNET )*/ 02753 02754 #ifdef GX_UNICODE /*(*/ 02755 02759 inline gxImageHandler(gxInStr propname, gxInStr modname) gxFuncThrowsError { 02760 GX_GETSTRING(_propname, propname); 02761 GX_GETSTRING(_modname, modname); 02762 #ifndef GX_DOTNET 02763 if(!gx_openmodule(this, _modname, _propname)) gxthrow; 02764 #else 02765 GX_GETHANDLE(h); 02766 if(!gx_openmodule(&h, _modname, _propname)) gxthrow; 02767 _set_handle(h.handle); 02768 #endif 02769 } 02773 inline gxImageHandler(gxInStr propname) gxFuncThrowsError { 02774 GX_GETSTRING(_propname, propname); 02775 #ifndef GX_DOTNET 02776 if(!gx_openmodule(this, L"gximage", _propname)) gxthrow; 02777 #else 02778 GX_GETHANDLE(h); 02779 if(!gx_openmodule(&h, L"gximage", _propname)) gxthrow; 02780 _set_handle(h.handle); 02781 #endif 02782 } 02783 #endif /* GX_UNICODE )*/ 02784 02785 #ifdef GX_ASCII 02786 02790 inline gxImageHandler(gxInAStr propname, gxInAStr modname) gxFuncThrowsError { 02791 GX_GETASTRING(_propname, propname); 02792 GX_GETASTRING(_modname, modname); 02793 if(!gx_openmodulea(this, _modname, _propname)) gxthrow; 02794 } 02797 inline gxImageHandler(gxInAStr propname) gxFuncThrowsError { 02798 GX_GETASTRING(_propname, propname); 02799 if(!gx_openmodulea(this, "gximage", _propname)) gxthrow; 02800 } 02801 #endif 02802 02806 inline gxImageHandler(GX_CONST gxImageHandler GX_REF_CLASS(src)) gxFuncThrowsError : gxHandle() { 02807 #ifndef GX_DOTNET 02808 handle = src.handle; 02809 if(!gx_refhandle(*this)) gxthrow; 02810 #else 02811 gxHANDLE h = { src GX_M _get_handle() }; 02812 if(!gx_refhandle(h)) gxthrow; 02813 _set_handle(h.handle); 02814 #endif 02815 } 02816 02817 }; 02818 02819 #endif /* GX_EXT_MODULE )*/ 02820 /******************************************************************************/ 02821 #if !defined(GX_MANUAL) 02822 #if !defined(GX_DOTNET) 02823 #define GX_GETIMAGE(name) gxIMAGE *name = _image 02824 #define GX_GETIMAGE2(name,src) gxIMAGE *name = (src)._image 02825 #else 02826 #define GX_GETIMAGE(name) gxIMAGE *name = (gxIMAGE *)_get_image().ToPointer() 02827 #define GX_GETIMAGE2(name,src) gxIMAGE *name = (gxIMAGE *)((src) GX_M _get_image().ToPointer()) 02828 #endif 02829 #endif 02830 02831 /******************************************************************************/ 02832 02833 #ifndef GX_EXT_MODULE /*(*/ 02834 /******************************************************************************/ 02835 /******************************************************************************/ 02837 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 02838 class gxImage : public gxImageHandler, public gxImageData { 02839 #else /*)(*/ 02840 GX_CLASS gxImage : public gxImageHandler 02841 #ifdef GX_DOTNET 02842 , public System::IDisposable 02843 #endif 02844 { 02845 02846 #if !defined(GX_SWIGIF) /*(*/ 02847 02848 #if !defined(GX_DOTNET) && !defined(GX_MANUAL) 02849 public: 02850 GX_INDIRECTION_NOGC(gxIMAGE) _image; /* Pointer to the allocated gxIMAGE structure. */ 02851 #endif 02852 02853 #if defined(GX_DOTNET) 02854 #if !defined(GX_MANUAL) 02855 private: 02856 GX_INDIRECTION_NOGC(gxIMAGE) _image; /* Pointer to the allocated gxIMAGE structure. */ 02857 #endif 02858 02859 public: 02865 inline gxOutPtr _get_image(void) GX_CONST { 02866 return GX_PUTPTR(_image); 02867 } 02873 inline void _set_image(gxInPtr ptr) { 02874 _image = (GX_INDIRECTION_NOGC(gxIMAGE))GX_GETPTR(ptr); 02875 } 02878 private: 02879 inline void _set_image(GX_INDIRECTION_NOGC(gxIMAGE) ptr) { 02880 _image = ptr; 02881 } 02882 public: 02883 #endif 02884 #endif /*)*/ 02885 02886 public: 02889 inline gxi32 ref(void) GX_CONST gxFuncThrowsError { 02890 gxassert(_image); 02891 return _image->ref; 02892 } 02893 02896 inline gxi32 simage(void) GX_CONST gxFuncThrowsError { 02897 gxassert(_image); 02898 return _image->simage; 02899 } 02902 inline gxi32 format(void) GX_CONST gxFuncThrowsError { 02903 gxassert(_image); 02904 return _image->format; 02905 } 02908 inline gxi32 xsize(void) GX_CONST gxFuncThrowsError { 02909 gxassert(_image); 02910 return _image->xsize; 02911 } 02914 inline gxi32 ysize(void) GX_CONST gxFuncThrowsError { 02915 gxassert(_image); 02916 return _image->ysize; 02917 } 02920 inline gxi32 sline(void) GX_CONST gxFuncThrowsError { 02921 gxassert(_image); 02922 return _image->sline; 02923 } 02926 inline gxi32 xres(void) GX_CONST gxFuncThrowsError { 02927 gxassert(_image); 02928 return _image->xres; 02929 } 02932 inline gxi32 yres(void) GX_CONST gxFuncThrowsError { 02933 gxassert(_image); 02934 return _image->yres; 02935 } 02938 inline void xres(gxi32 _xres) gxFuncThrowsError { 02939 gxassert(_image); 02940 _image->xres = _xres; 02941 } 02944 inline void yres(gxi32 _yres) gxFuncThrowsError { 02945 gxassert(_image); 02946 _image->yres = _yres; 02947 } 02948 02951 inline gxi32 GetRef(void) GX_CONST gxFuncThrowsError { 02952 return ref(); 02953 } 02954 02957 #if defined(GX_DOTNET) 02958 inline gxOutData GetPixels(void) GX_CONST gxFuncThrowsError { 02959 return GX_PUTDATA(_image->image, _image->simage); 02960 } 02961 #elif defined(GX_SWIG) 02962 inline gxOutData GetPixels(void) GX_CONST gxFuncThrowsError { 02963 return GX_PUTDATA(image(), simage()); 02964 } 02965 #else 02966 inline void *GetPixels(void) GX_CONST gxFuncThrowsError { 02967 return image(); 02968 } 02969 #endif 02970 02973 inline gxi32 GetSImage(void) GX_CONST gxFuncThrowsError { 02974 return simage(); 02975 } 02978 inline gxi32 GetPixelFormat(void) GX_CONST gxFuncThrowsError { 02979 return format(); 02980 } 02983 inline gxi32 GetXSize(void) GX_CONST gxFuncThrowsError { 02984 return xsize(); 02985 } 02988 inline gxi32 GetYSize(void) GX_CONST gxFuncThrowsError { 02989 return ysize(); 02990 } 02993 inline gxi32 GetSLine(void) GX_CONST gxFuncThrowsError { 02994 return sline(); 02995 } 02998 inline gxi32 GetXRes(void) GX_CONST gxFuncThrowsError { 02999 return xres(); 03000 } 03003 inline gxi32 GetYRes(void) GX_CONST gxFuncThrowsError { 03004 return yres(); 03005 } 03009 inline bool SetXRes(gxi32 _xres) gxFuncThrowsError { 03010 xres(_xres); 03011 return true; 03012 } 03016 inline bool SetYRes(gxi32 _yres) gxFuncThrowsError { 03017 yres(_yres); 03018 return true; 03019 } 03020 #endif /*)*/ 03021 public: 03022 #if defined(GX_DOTNET) || defined(GX_SWIGIF) /*(*/ 03023 03024 inline gxImage() gxFuncThrowsError : gxImageHandler() { 03025 _image = 0; 03026 if(gxHandle::IsValid()) { 03027 #ifndef GX_DOTNET 03028 if(!gx_allocimage(*this, &_image)) gxthrow; 03029 #else 03030 GX_GETHANDLE(h); 03031 GX_GETIMAGE(i); 03032 if(!gx_allocimage(h, &i)) gxthrow; 03033 _set_image(i); 03034 #endif 03035 } 03036 } 03037 #endif /*)*/ 03038 03039 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 03040 03041 inline gxImage() gxFuncThrowsError : gxImageHandler(), gxImageData() { 03042 if(gxHandle::IsValid()) { 03043 if(!gx_allocimage(*this, &_image)) gxthrow; 03044 } 03045 } 03046 03050 inline gxImage(const gxHANDLE &h) gxFuncThrowsError : gxImageHandler(h), gxImageData() { 03051 if(gxHandle::IsValid()) { 03052 if(!gx_allocimage(*this, &_image)) gxthrow; 03053 } 03054 } 03058 inline gxImage(const gxHANDLE *h) gxFuncThrowsError : gxImageHandler(h), gxImageData() { 03059 if(gxHandle::IsValid()) { 03060 if(!gx_allocimage(*this, &_image)) gxthrow; 03061 } 03062 } 03063 03068 inline gxImage(const wchar_t *propname, 03069 const wchar_t *modname = (const wchar_t *)0) gxFuncThrowsError 03070 : gxImageHandler(propname, modname), gxImageData() { 03071 03072 if(gxHandle::IsValid()) { 03073 if(!gx_allocimage(*this, &_image)) gxthrow; 03074 } 03075 } 03076 03081 inline gxImage(const char *propname, 03082 const char *modname = (const char *)0) gxFuncThrowsError 03083 : gxImageHandler(propname, modname), gxImageData() { 03084 03085 if(gxHandle::IsValid()) { 03086 if(!gx_allocimage(*this, &_image)) gxthrow; 03087 } 03088 } 03089 03092 inline gxImage(gxIMAGE &src) gxFuncThrowsError : gxImageHandler(), gxImageData() { 03093 if(gxHandle::IsValid()) { 03094 if(gx_allocimage(*this, &_image)) { 03095 Copy(src); 03096 } else { 03097 gxthrow; 03098 } 03099 } 03100 } 03101 03107 inline gxImage(gxIMAGE &src, const wchar_t *propname, 03108 const wchar_t *modname = (const wchar_t *)0) gxFuncThrowsError 03109 : gxImageHandler(propname, modname), gxImageData() { 03110 03111 if(gxHandle::IsValid()) { 03112 if(gx_allocimage(*this, &_image)) { 03113 Copy(src); 03114 } else { 03115 gxthrow; 03116 } 03117 } 03118 } 03119 03125 inline gxImage(gxIMAGE &src, const char *propname, 03126 const char *modname = (const char *)0) gxFuncThrowsError 03127 : gxImageHandler(propname, modname), gxImageData() { 03128 03129 if(gxHandle::IsValid()) { 03130 if(gx_allocimage(*this, &_image)) { 03131 Copy(src); 03132 } else { 03133 gxthrow; 03134 } 03135 } 03136 } 03137 03143 inline gxImage(gxImage &src, const wchar_t *propname, const wchar_t *modname = (const wchar_t *)0) 03144 gxFuncThrowsError : gxImageHandler(propname, modname), gxImageData() { 03145 03146 if(gxHandle::IsValid()) { 03147 if(gx_allocimage(*this, &_image)) { 03148 Copy(src); 03149 } else { 03150 gxthrow; 03151 } 03152 } 03153 } 03154 03160 inline gxImage(gxImage &src, const char *propname, 03161 const char *modname = (const char *)0) gxFuncThrowsError 03162 : gxImageHandler(propname, modname), gxImageData() { 03163 03164 if(gxHandle::IsValid()) { 03165 if(gx_allocimage(*this, &_image)) { 03166 Copy(src); 03167 } else { 03168 gxthrow; 03169 } 03170 } 03171 } 03172 #endif /*)*/ 03173 03174 #ifdef GX_UNICODE /*(*/ 03175 03178 #ifndef GX_DOTNET 03179 inline gxImage(gxInStr propname) gxFuncThrowsError 03180 : gxImageHandler(propname), gxImageData() { 03181 03182 if(gxHandle::IsValid()) { 03183 if(!gx_allocimage(*this, &_image)) gxthrow; 03184 } 03185 } 03186 #else 03187 inline gxImage(gxInStr propname) gxFuncThrowsError 03188 : gxImageHandler(propname) { 03189 03190 _set_image(0); 03191 if(gxHandle::IsValid()) { 03192 GX_GETHANDLE(h); 03193 GX_GETIMAGE(i); 03194 if(!gx_allocimage(h, &i)) gxthrow; 03195 _set_image(i); 03196 } 03197 } 03198 #endif 03199 03204 #ifndef GX_DOTNET 03205 inline gxImage(gxInStr propname, gxInStr modname) gxFuncThrowsError 03206 : gxImageHandler(propname, modname), gxImageData() { 03207 if(gxHandle::IsValid()) { 03208 if(!gx_allocimage(*this, &_image)) gxthrow; 03209 } 03210 } 03211 #else 03212 inline gxImage(gxInStr propname, gxInStr modname) gxFuncThrowsError 03213 : gxImageHandler(propname, modname) { 03214 03215 _set_image(0); 03216 if(gxHandle::IsValid()) { 03217 GX_GETHANDLE(h); 03218 GX_GETIMAGE(i); 03219 if(!gx_allocimage(h, &i)) gxthrow; 03220 _set_image(i); 03221 } 03222 } 03223 #endif 03224 03225 #endif /*)*/ 03226 03227 #ifdef GX_ASCII 03228 03231 inline gxImage(gxInAStr propname) gxFuncThrowsError 03232 : gxImageHandler(propname), gxImageData() { 03233 03234 if(gxHandle::IsValid()) { 03235 if(!gx_allocimage(*this, &_image)) gxthrow; 03236 } 03237 } 03242 inline gxImage(gxInAStr propname, gxInAStr modname) gxFuncThrowsError 03243 : gxImageHandler(propname, modname), gxImageData() { 03244 if(gxHandle::IsValid()) { 03245 if(!gx_allocimage(*this, &_image)) gxthrow; 03246 } 03247 } 03248 #endif 03249 03253 #ifndef GX_DOTNET 03254 inline gxImage(gxImageHandler &ih) gxFuncThrowsError : gxImageHandler(ih), gxImageData() { 03255 if(gxHandle::IsValid()) { 03256 if(!gx_allocimage(*this, &_image)) gxthrow; 03257 } 03258 } 03259 #else 03260 03261 inline gxImage(gxImageHandler GX_REF_CLASS(ih)) gxFuncThrowsError : gxImageHandler(ih) { 03262 03263 _set_image(GX_NULLPTR); 03264 if(gxHandle::IsValid()) { 03265 GX_GETHANDLE(h); 03266 GX_GETIMAGE(i); 03267 if(!gx_allocimage(h, &i)) gxthrow; 03268 _set_image(i); 03269 03270 } 03271 } 03272 #endif 03273 03277 #ifndef GX_DOTNET 03278 inline gxImage(gxImage &src) gxFuncThrowsError : gxImageHandler((const gxHANDLE &)src), gxImageData() { 03279 if(gxHandle::IsValid()) { 03280 if(gx_allocimage(*this, &_image)) { 03281 Copy(src); 03282 } else { 03283 gxthrow; 03284 } 03285 } 03286 } 03287 #else 03288 inline gxImage(gxImage GX_REF_CLASS(src)) gxFuncThrowsError : gxImageHandler(src) { 03289 _set_image(0); 03290 if(gxHandle::IsValid()) { 03291 GX_GETHANDLE(h); 03292 GX_GETIMAGE(i); 03293 if(gx_allocimage(h, &i)) { 03294 _set_image(i); 03295 Copy(src); 03296 } else { 03297 gxthrow; 03298 } 03299 } 03300 } 03301 #endif 03302 03304 inline ~gxImage() gxFuncThrowsError { 03305 _Dispose(); 03306 } 03307 03308 #ifdef GX_DOTNET_20 03309 inline !gxImage() gxFuncThrowsError { 03310 _Dispose(); 03311 } 03312 #else 03313 03314 inline void Dispose(void) gxFuncThrowsError { 03315 #ifdef GX_DOTNET 03316 System::GC::SuppressFinalize(this);//do not call it from a destructor explicitly! 03317 #endif 03318 _Dispose(); 03320 gxHandle::Dispose(); 03321 } 03322 #endif 03323 03324 private: 03325 inline void _Dispose(void) gxFuncThrowsError { 03326 #ifndef GX_DOTNET 03327 if(_image) { 03328 if(!gx_unrefimage(*this, _image)) gxthrow; 03329 } 03330 #else 03331 GX_GETHANDLE(h); 03332 GX_GETIMAGE(i); 03333 if(i) { 03334 if(!gx_unrefimage(h, i)) gxthrow; 03335 } 03336 #endif 03337 _image=0; 03338 } 03339 03340 public: 03341 03342 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) /*(*/ 03343 03347 inline gxImage &operator = (gxIMAGE &src) gxFuncThrowsError { 03348 Copy(src); 03349 return *this; 03350 } 03351 03356 inline gxImage &operator = (gxImage &src) gxFuncThrowsError { 03357 Copy(src); 03358 return *this; 03359 } 03360 03363 inline operator gxIMAGE & () gxFuncThrowsError { 03364 gxassert(_image); 03365 return *_image; 03366 } 03369 inline operator gxIMAGE * () gxFuncThrowsError { 03370 gxassert(_image); 03371 return _image; 03372 } 03375 inline operator const gxIMAGE * () const gxFuncThrowsError { 03376 gxassert(_image); 03377 return _image; 03378 } 03379 03383 inline bool Attach(gxIMAGE *src) gxFuncThrowsError { 03384 gxassert(_image && src); 03385 if(src->ref >= 0) { 03386 gx_seterror(GX_EINVAL, L"(src->ref < 0)"); 03387 gxthrow; 03388 return false; 03389 } 03390 if(!gx_refimage(*this, src)) { 03391 gxthrow; 03392 return false; 03393 } 03394 if(!gx_unrefimage(*this, _image)) { 03395 gx_unrefimage(*this, src); 03396 gxthrow; 03397 return false; 03398 } 03399 _image = src; 03400 return true; 03401 } 03402 03405 inline bool Detach(void) gxFuncThrowsError { 03406 if(!gx_unrefimage(*this, _image)) { 03407 gxthrow; 03408 return false; 03409 } 03410 if(!gx_allocimage(*this, &_image)) { 03411 gxthrow; 03412 return false; 03413 } 03414 return true; 03415 } 03416 03420 inline bool GetPixelSize(gxi32 *size) const gxFuncThrowsError { 03421 if(!gx_getpixelsize(*this, size, format())) { 03422 throw gxError(); 03423 return false; 03424 } 03425 return true; 03426 } 03427 03433 inline void *GetPixelPtr(gxi32 x, gxi32 y) gxFuncThrowsError { 03434 gxassert(_image); 03435 void *ret = gx_getpixelptr(*this, _image, x, y); 03436 gxcondthrow(!ret); 03437 return ret; 03438 } 03439 #endif /*)*/ 03440 03442 inline gxi32 GetPixelSize(void) GX_CONST gxFuncThrowsError { 03443 gxi32 size = -1; 03444 GX_GETHANDLE(h); 03445 if(!gx_getpixelsize(h, &size, format())) gxthrow; 03446 return size; 03447 } 03448 03456 inline bool Create(gxi32 format, gxi32 xsize, gxi32 ysize, gxi32 sline GX_DEFARG(0)) gxFuncThrowsError { 03457 gxassert(_image); 03458 GX_GETHANDLE(h); 03459 bool st = gx_createimage(h, _image, format, xsize, ysize, sline) ? true : false; 03460 gxcondthrow(!st); 03461 return st; 03462 } 03463 03464 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 03465 03473 inline bool Convert(gxIMAGE *src, gxi32 format, gxi32 xsize, gxi32 ysize, gxi32 sline GX_DEFARG(0)) gxFuncThrowsError { 03474 gxassert(_image); 03475 bool st = gx_convertimage(*this, _image, src, format, xsize, ysize, sline) ? true : false; 03476 gxcondthrow(!st); 03477 return st; 03478 } 03479 #endif 03480 03488 inline bool Convert(gxImageData GX_REF_CLASS(src), gxi32 format, gxi32 xsize, gxi32 ysize, gxi32 sline GX_DEFARG(0)) gxFuncThrowsError { 03489 gxassert(_image); 03490 GX_GETHANDLE(h); 03491 #ifndef GX_DOTNET 03492 bool st = gx_convertimage(h, _image, src._image, format, xsize, ysize, sline) ? true : false; 03493 #else 03494 bool st = gx_convertimage(h, _image, (gxIMAGE *)src GX_M _get_image().ToPointer(), format, xsize, ysize, sline) ? true : false; 03495 #endif 03496 gxcondthrow(!st); 03497 return st; 03498 } 03499 03508 inline bool Convert(gxImage GX_REF_CLASS(src), gxi32 format, gxi32 xsize, gxi32 ysize, gxi32 sline GX_DEFARG(0)) gxFuncThrowsError { 03509 gxassert(_image); 03510 GX_GETHANDLE(h); 03511 bool st = gx_convertimage(h, _image, src GX_M _image, format, xsize, ysize, sline) ? true : false; 03512 gxcondthrow(!st); 03513 return st; 03514 } 03515 03523 inline bool Convert(gxi32 format, gxi32 xsize, gxi32 ysize, gxi32 sline GX_DEFARG(0)) gxFuncThrowsError { 03524 gxassert(_image); 03525 GX_GETHANDLE(h); 03526 bool st = gx_convertimage(h, _image, _image, format, xsize, ysize, sline) ? true : false; 03527 gxcondthrow(!st); 03528 return st; 03529 } 03530 03534 inline bool Convert(gxi32 format) gxFuncThrowsError { 03535 gxassert(_image); 03536 GX_GETHANDLE(h); 03537 bool st = gx_convertimage(h, _image, _image, format, xsize(), ysize(), 0) ? true : false; 03538 gxcondthrow(!st); 03539 return st; 03540 } 03541 03542 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 03543 03546 inline bool Copy(gxIMAGE *src) gxFuncThrowsError { 03547 gxassert(_image); 03548 bool st = gx_copyimage(*this, _image, src) ? true : false; 03549 gxcondthrow(!st); 03550 return st; 03551 } 03552 03556 inline bool Copy(gxIMAGE &src) gxFuncThrowsError { 03557 gxassert(_image); 03558 bool st = gx_copyimage(*this, _image, &src) ? true : false; 03559 gxcondthrow(!st); 03560 return st; 03561 } 03562 03566 inline bool Copy(gxImage *src) gxFuncThrowsError { 03567 gxassert(src); 03568 return Copy((gxIMAGE *)(*src)); 03569 } 03570 #endif 03571 03575 inline bool Copy(gxImageData GX_REF_CLASS(src)) gxFuncThrowsError { 03576 #ifndef GX_DOTNET 03577 return Copy((gxIMAGE &)src); 03578 #else 03579 GX_GETHANDLE(h); 03580 GX_GETIMAGE(i); 03581 bool st = gx_copyimage(h, i, (gxIMAGE *)src GX_M _get_image().ToPointer()) ? true : false; 03582 gxcondthrow(!st); 03583 return st; 03584 #endif 03585 } 03586 03590 inline bool Copy(gxImage GX_REF_CLASS(src)) gxFuncThrowsError { 03591 #ifndef GX_DOTNET 03592 return Copy((gxIMAGE &)src); 03593 #else 03594 GX_GETHANDLE(h); 03595 GX_GETIMAGE(i); 03596 bool st = gx_copyimage(h, i, (gxIMAGE *)src GX_M _get_image().ToPointer()) ? true : false; 03597 gxcondthrow(!st); 03598 return st; 03599 #endif 03600 } 03601 03602 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 03603 03613 inline bool Zoom(gxIMAGE *src, gxi32 xsize, gxi32 ysize, gxi32 sline, 03614 gxi32 sx1_8 GX_DEFARG(0), gxi32 sy1_8 GX_DEFARG(0), 03615 gxi32 sx2_8 GX_DEFARG(0), gxi32 sy2_8 GX_DEFARG(0)) gxFuncThrowsError { 03616 gxassert(_image); 03617 bool st = gx_zoomimage(*this, _image, xsize, ysize, sline, src, 03618 sx1_8, sy1_8, sx2_8, sy2_8) ? true : false; 03619 gxcondthrow(!st); 03620 return st; 03621 } 03622 #endif 03623 03634 inline bool Zoom(gxImageData GX_REF_CLASS(src), gxi32 xsize, gxi32 ysize, gxi32 sline, 03635 gxi32 sx1_8 GX_DEFARG(0), gxi32 sy1_8 GX_DEFARG(0), 03636 gxi32 sx2_8 GX_DEFARG(0), gxi32 sy2_8 GX_DEFARG(0)) gxFuncThrowsError { 03637 gxassert(_image); 03638 #ifndef GX_DOTNET 03639 bool st = gx_zoomimage(*this, _image, xsize, ysize, sline, src, 03640 sx1_8, sy1_8, sx2_8, sy2_8) ? true : false; 03641 #else 03642 GX_GETHANDLE(h); 03643 GX_GETIMAGE(i); 03644 bool st = gx_zoomimage(h, i, xsize, ysize, sline, 03645 (gxIMAGE *)src GX_M _get_image().ToPointer(), 03646 sx1_8, sy1_8, sx2_8, sy2_8) ? true : false; 03647 #endif 03648 gxcondthrow(!st); 03649 return st; 03650 } 03651 #ifdef GX_DOTNET 03652 03658 inline bool Zoom(gxImageData GX_REF_CLASS(src), gxi32 xsize, gxi32 ysize, gxi32 sline) gxFuncThrowsError { 03659 return false; 03660 //return Zoom(src, xsize, ysize, sline, 0,0,0,0); 03661 } 03662 #endif 03663 03674 inline bool Zoom(gxImage GX_REF_CLASS(src), gxi32 xsize, gxi32 ysize, gxi32 sline, 03675 gxi32 sx1_8 GX_DEFARG(0), gxi32 sy1_8 GX_DEFARG(0), 03676 gxi32 sx2_8 GX_DEFARG(0), gxi32 sy2_8 GX_DEFARG(0)) gxFuncThrowsError { 03677 gxassert(_image); 03678 #ifndef GX_DOTNET 03679 bool st = gx_zoomimage(*this, _image, xsize, ysize, sline, src, 03680 sx1_8, sy1_8, sx2_8, sy2_8) ? true : false; 03681 #else 03682 GX_GETHANDLE(h); 03683 GX_GETIMAGE(i); 03684 bool st = gx_zoomimage(h, i, xsize, ysize, sline, 03685 (gxIMAGE *)src GX_M _get_image().ToPointer(), 03686 sx1_8, sy1_8, sx2_8, sy2_8) ? true : false; 03687 #endif 03688 gxcondthrow(!st); 03689 return st; 03690 } 03691 #ifdef GX_DOTNET 03692 03698 inline bool Zoom(gxImage GX_REF_CLASS(src), gxi32 xsize, gxi32 ysize, gxi32 sline) gxFuncThrowsError { 03699 return Zoom(src, xsize, ysize, sline, 0,0,0,0); 03700 } 03701 #endif 03702 03703 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 03704 03708 inline bool Rotate(gxIMAGE *src, gxi32 degree) gxFuncThrowsError { 03709 gxassert(_image); 03710 bool st = gx_rotateimage(*this, _image, src, degree) ? true : false; 03711 gxcondthrow(!st); 03712 return st; 03713 } 03714 #endif 03715 03720 inline bool Rotate(gxImageData GX_REF_CLASS(src), gxi32 degree) gxFuncThrowsError { 03721 gxassert(_image); 03722 #ifndef GX_DOTNET 03723 bool st = gx_rotateimage(*this, _image, src, degree) ? true : false; 03724 #else 03725 GX_GETHANDLE(h); 03726 GX_GETIMAGE(i); 03727 bool st = gx_rotateimage(h, i, (gxIMAGE *)src GX_M _get_image().ToPointer(), degree) ? true : false; 03728 #endif 03729 gxcondthrow(!st); 03730 return st; 03731 } 03732 03737 inline bool Rotate(gxImage GX_REF_CLASS(src), gxi32 degree) gxFuncThrowsError { 03738 gxassert(_image); 03739 #ifndef GX_DOTNET 03740 bool st = gx_rotateimage(*this, _image, src, degree) ? true : false; 03741 #else 03742 GX_GETHANDLE(h); 03743 GX_GETIMAGE(i); 03744 bool st = gx_rotateimage(h, i, (gxIMAGE *)src GX_M _get_image().ToPointer(), degree) ? true : false; 03745 #endif 03746 gxcondthrow(!st); 03747 return st; 03748 } 03749 03750 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 03751 03755 inline bool Mirror(gxIMAGE *src, gxi32 flags) gxFuncThrowsError { 03756 gxassert(_image); 03757 bool st = gx_mirrorimage(*this, _image, src, flags) ? true : false; 03758 gxcondthrow(!st); 03759 return st; 03760 } 03761 #endif 03762 03766 inline bool Mirror(gxImageData GX_REF_CLASS(src), gxi32 flags) { 03767 gxassert(_image); 03768 #ifndef GX_DOTNET 03769 bool st = gx_mirrorimage(*this, _image, src, flags) ? true : false; 03770 #else 03771 GX_GETHANDLE(h); 03772 GX_GETIMAGE(i); 03773 bool st = gx_mirrorimage(h, i, (gxIMAGE *)src GX_M _get_image().ToPointer(), flags) ? true : false; 03774 #endif 03775 gxcondthrow(!st); 03776 return st; 03777 } 03778 03783 inline bool Mirror(gxImage GX_REF_CLASS(src), gxi32 flags) { 03784 gxassert(_image); 03785 #ifndef GX_DOTNET 03786 bool st = gx_mirrorimage(*this, _image, src, flags) ? true : false; 03787 #else 03788 GX_GETHANDLE(h); 03789 GX_GETIMAGE(i); 03790 bool st = gx_mirrorimage(h, i, (gxIMAGE *)src GX_M _get_image().ToPointer(), flags) ? true : false; 03791 #endif 03792 gxcondthrow(!st); 03793 return st; 03794 } 03795 03799 inline bool Mirror(gxi32 flags) { 03800 gxassert(_image); 03801 GX_GETHANDLE(h); 03802 GX_GETIMAGE(i); 03803 bool st = gx_mirrorimage(h, i, flags) ? true : false; 03804 gxcondthrow(!st); 03805 return st; 03806 } 03807 03808 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 03809 03829 inline bool Load(const wchar_t *filename, gxi32 pixelformat GX_DEFARG(GX_UNDEF), 03830 gxVARIANT properties GX_DEFARG(0), 03831 gxVARIANT comments GX_DEFARG(0)) gxFuncThrowsError { 03832 gxassert(_image); 03833 bool st = gx_loadimagefromfile(_image, filename, pixelformat, 03834 properties, comments) ? true : false; 03835 gxcondthrow(!st); 03836 return st; 03837 } 03838 03859 inline bool Load(const char *filename, gxi32 pixelformat GX_DEFARG(GX_UNDEF), 03860 gxVARIANT properties GX_DEFARG(0), 03861 gxVARIANT comments GX_DEFARG(0)) gxFuncThrowsError { 03862 gxassert(_image); 03863 bool st = gx_loadimagefromfile(_image, filename, pixelformat, 03864 properties, comments) ? true : false; 03865 gxcondthrow(!st); 03866 return st; 03867 } 03868 #endif 03869 #ifdef GX_UNICODE 03870 03892 inline bool Load(gxInStr filename, gxi32 pixelformat, 03893 #ifndef GX_DOTNET 03894 gxVariant &properties, gxVariant &comments 03895 #else 03896 #ifndef GX_DOTNET_20 03897 gxVariant *properties, gxVariant *comments 03898 #else 03899 gxVariant ^properties, gxVariant ^comments 03900 #endif 03901 #endif 03902 ) gxFuncThrowsError { 03903 03904 GX_GETSTRING(_filename, filename); 03905 GX_GETIMAGE(i); 03906 bool st = gx_loadimagefromfile(i, _filename, pixelformat, 03907 #ifndef GX_DOTNET 03908 properties._variant, comments._variant 03909 #else 03910 properties ? properties->_variant : 0, 03911 comments ? comments->_variant : 0 03912 #endif 03913 ) ? true : false; 03914 gxcondthrow(!st); 03915 return st; 03916 } 03917 03938 inline bool Load(gxInStr filename, gxi32 pixelformat) gxFuncThrowsError { 03939 03940 GX_GETSTRING(_filename, filename); 03941 GX_GETHANDLE(h); 03942 GX_GETIMAGE(i); 03943 bool st = gx_loadimage(h, i, _filename, pixelformat) ? true : false; 03944 gxcondthrow(!st); 03945 return st; 03946 } 03947 03951 inline bool Load(gxInStr filename) gxFuncThrowsError { 03952 GX_GETSTRING(_filename, filename); 03953 GX_GETHANDLE(h); 03954 GX_GETIMAGE(i); 03955 bool st = gx_loadimage(h, i, _filename, (int)GX_ENUM_PATH(GX_PIXELFORMATS) GX_UNDEF) ? true : false; 03956 gxcondthrow(!st); 03957 return st; 03958 } 03959 #endif 03960 #ifdef GX_ASCII 03961 03981 inline bool Load(gxInAStr filename, gxi32 pixelformat, 03982 gxVariant &properties, gxVariant &comments) gxFuncThrowsError { 03983 03984 GX_GETASTRING(_filename, filename); 03985 bool st = gx_loadimagefromfile(_image, _filename, pixelformat, 03986 properties._variant, comments._variant) ? true : false; 03987 gxcondthrow(!st); 03988 return st; 03989 } 03990 04009 inline bool Load(gxInAStr filename, gxi32 pixelformat GX_DEFARG(GX_UNDEF)) gxFuncThrowsError { 04010 GX_GETASTRING(_filename, filename); 04011 bool st = gx_loadimage(*this, _image, _filename, pixelformat) ? true : false; 04012 gxcondthrow(!st); 04013 return st; 04014 } 04015 #endif 04016 04017 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 04018 04023 inline bool Save(const wchar_t *filename, gxi32 fileformat) gxFuncThrowsError { 04024 gxassert(_image); 04025 bool st = gx_saveimage(*this, _image, filename, fileformat) ? true : false; 04026 gxcondthrow(!st); 04027 return st; 04028 } 04029 04035 inline bool Save(const char *filename, gxi32 fileformat) gxFuncThrowsError { 04036 gxassert(_image); 04037 bool st = gx_saveimage(*this, _image, filename, fileformat) ? true : false; 04038 gxcondthrow(!st); 04039 return st; 04040 } 04041 04049 inline bool Save(const wchar_t *filename, gxi32 fileformat, 04050 gxVariant &properties, gxVariant &comments) gxFuncThrowsError { 04051 04052 gxassert(_image); 04053 bool st = gx_saveimagetofile(_image, filename, fileformat, 04054 properties._variant, comments._variant) ? true : false; 04055 gxcondthrow(!st); 04056 return st; 04057 } 04058 04066 inline bool Save(const char *filename, gxi32 fileformat, 04067 gxVariant &properties, gxVariant &comments) gxFuncThrowsError { 04068 gxassert(_image); 04069 bool st = gx_saveimagetofile(_image, filename, fileformat, 04070 properties._variant, comments._variant) ? true : false; 04071 gxcondthrow(!st); 04072 return st; 04073 } 04074 #endif 04075 #ifdef GX_UNICODE 04076 04083 inline bool Save(gxInStr filename, gxi32 fileformat, 04084 gxVariant GX_REF_CLASS(properties), gxVariant GX_REF_CLASS(comments) 04085 ) gxFuncThrowsError { 04086 04087 GX_GETSTRING(_filename, filename); 04088 GX_GETIMAGE(i); 04089 bool st = gx_saveimagetofile(i, _filename, fileformat, 04090 #ifndef GX_DOTNET 04091 properties._variant, comments._variant 04092 #else 04093 properties ? properties->_variant : 0, 04094 comments ? comments->_variant : 0 04095 #endif 04096 ) ? true : false; 04097 gxcondthrow(!st); 04098 return st; 04099 } 04100 04106 inline bool Save(gxInStr filename, gxi32 fileformat) gxFuncThrowsError { 04107 GX_GETSTRING(_filename, filename); 04108 GX_GETHANDLE(h); 04109 GX_GETIMAGE(i); 04110 bool st = gx_saveimage(h, i, _filename, fileformat) ? true : false; 04111 gxcondthrow(!st); 04112 return st; 04113 } 04114 #endif 04115 #ifdef GX_ASCII 04116 04123 inline bool Save(gxInAStr filename, gxi32 fileformat, 04124 gxVariant &properties, gxVariant &comments) gxFuncThrowsError { 04125 GX_GETASTRING(_filename, filename); 04126 return Save(_filename, fileformat, properties, comments); 04127 } 04128 04134 inline bool Save(gxInAStr filename, gxi32 fileformat) gxFuncThrowsError { 04135 GX_GETASTRING(_filename, filename); 04136 return Save(_filename, fileformat); 04137 } 04138 #endif 04139 04140 #if !defined(GX_SWIGIF) && !defined(GX_DOTNET) 04141 04155 inline bool LoadFromMem(const void *buffer, gxi32 buflen, gxi32 pixelformat, 04156 gxVariant &properties, gxVariant &comments) gxFuncThrowsError { 04157 gxassert(_image); 04158 bool st = gx_loadimagefrommem(_image, buffer, buflen, pixelformat, 04159 properties._variant, comments._variant) ? true : false; 04160 gxcondthrow(!st); 04161 return st; 04162 } 04163 04172 inline bool SaveToMem(void **buffer, gxi32 *buflen, gxi32 fileformat, 04173 gxVariant &properties, gxVariant &comments) gxFuncThrowsError { 04174 gxassert(_image); 04175 bool st = gx_saveimagetomem(_image, buffer, buflen, fileformat, 04176 properties._variant, comments._variant) ? true : false; 04177 gxcondthrow(!st); 04178 return st; 04179 } 04180 04192 inline bool LoadFromMem(const void *buffer, gxi32 buflen, gxi32 pixelformat GX_DEFARG(GX_UNDEF)) gxFuncThrowsError { 04193 gxassert(_image); 04194 bool st = gx_loadfrommem(*this, _image, buffer, buflen, pixelformat) ? true : false; 04195 gxcondthrow(!st); 04196 return st; 04197 } 04198 04204 inline bool SaveToMem(void **buffer, gxi32 *buflen, gxi32 fileformat) gxFuncThrowsError { 04205 gxassert(_image); 04206 bool st = gx_savetomem(*this, _image, buffer, buflen, fileformat) ? true : false; 04207 gxcondthrow(!st); 04208 return st; 04209 } 04210 #endif 04211 04212 #if defined(GX_SWIG) || defined(GX_DOTNET) /*(*/ 04213 04226 inline bool LoadFromMem(gxInData buffer, gxi32 pixelformat, 04227 gxVariant GX_REF_CLASS(properties), gxVariant GX_REF_CLASS(comments) 04228 ) gxFuncThrowsError { 04229 04230 GX_GETDATA(buffer); 04231 GX_GETIMAGE(i); 04232 bool st = gx_loadimagefrommem(i, GX_DATAPTR(buffer), GX_DATALEN(buffer), pixelformat, 04233 #ifndef GX_DOTNET 04234 properties._variant, comments._variant 04235 #else 04236 properties ? properties->_variant : 0, 04237 comments ? comments->_variant : 0 04238 #endif 04239 ) ? true : false; 04240 GX_FREEDATA(buffer); 04241 if(!st) gxthrow; 04242 return st; 04243 } 04244 04250 inline gxOutData SaveToMem(gxi32 fileformat, 04251 gxVariant GX_REF_CLASS(properties), gxVariant GX_REF_CLASS(comments) 04252 ) gxFuncThrowsError { 04253 04254 void *buffer = (void *)0; 04255 gxi32 buflen = 0; 04256 GX_GETIMAGE(i); 04257 if(!gx_saveimagetomem(i, &buffer, &buflen, fileformat, 04258 #ifndef GX_DOTNET 04259 properties._variant, comments._variant 04260 #else 04261 properties ? properties->_variant : 0, 04262 comments ? comments->_variant : 0 04263 #endif 04264 )) { 04265 gxthrow; 04266 return GX_PUTDATA_NONE; 04267 } 04268 gxOutData ret = GX_PUTDATA(buffer, buflen); 04269 if(buffer) gx_globalfree(buffer); 04270 return ret; 04271 } 04272 04283 inline bool LoadFromMem(gxInData buffer, gxi32 pixelformat) gxFuncThrowsError { 04284 GX_GETDATA(buffer); 04285 GX_GETHANDLE(h); 04286 GX_GETIMAGE(i); 04287 bool st = gx_loadfrommem(h, i, GX_DATAPTR(buffer), GX_DATALEN(buffer), pixelformat) ? true : false; 04288 GX_FREEDATA(buffer); 04289 if(!st) gxthrow; 04290 return st; 04291 } 04292 04296 inline gxOutData SaveToMem(gxi32 fileformat) gxFuncThrowsError 04297 { 04298 void *buffer = (void *)0; 04299 gxi32 buflen = 0; 04300 GX_GETHANDLE(h); 04301 GX_GETIMAGE(i); 04302 if(!gx_savetomem(h, i, &buffer, &buflen, fileformat)) { 04303 gxthrow; 04304 return GX_PUTDATA_NONE; 04305 } 04306 gxOutData ret = GX_PUTDATA(buffer, buflen); 04307 if(buffer) gx_globalfree(buffer); 04308 return ret; 04309 } 04310 #endif /*)*/ 04311 04314 inline bool IsValid(void) GX_CONST { 04315 if(!gxHandle::IsValid()) return false; 04316 GX_GETHANDLE(h); 04317 GX_GETIMAGE(i); 04318 return gx_isvalidimage(h, i) ? true : false; 04319 } 04320 04321 #ifdef WIN32 /*(*/ 04322 #if !defined(GX_SWIGIF) 04323 04330 #ifndef GX_DOTNET 04331 inline bool DisplayImage(HDC hdc, gxi32 x, gxi32 y, gxi32 xsize, gxi32 ysize) gxFuncThrowsError { 04332 gxassert(_image); 04333 bool st = gx_displayimage(*this, hdc, x, y, xsize, ysize, _image) ? true : false; 04334 gxcondthrow(!st); 04335 return st; 04336 } 04337 #else 04338 inline bool DisplayImage(gxInPtr hdc, gxi32 x, gxi32 y, gxi32 xsize, gxi32 ysize) gxFuncThrowsError { 04339 gxassert(_image); 04340 GX_GETHANDLE(h); 04341 bool st = gx_displayimage(h, hdc.ToPointer(), x, y, xsize, ysize, _image) ? true : false; 04342 gxcondthrow(!st); 04343 return st; 04344 } 04345 #endif 04346 #endif 04347 04350 inline bool Copy(void) gxFuncThrowsError { 04351 gxassert(_image); 04352 GX_GETHANDLE(h); 04353 GX_GETIMAGE(i); 04354 bool st = gx_imgtoclipboard(h, i) ? true : false; 04355 gxcondthrow(!st); 04356 return st; 04357 } 04358 04361 inline bool Paste(void) gxFuncThrowsError { 04362 gxassert(_image); 04363 GX_GETHANDLE(h); 04364 GX_GETIMAGE(i); 04365 bool st = gx_pasteimage(h, i) ? true : false; 04366 gxcondthrow(!st); 04367 return st; 04368 } 04369 #endif /*)*/ 04370 04375 inline bool FromVariant( 04376 gxVariant GX_REF_CLASS(variant) 04377 ) gxFuncThrowsError { 04378 04379 GX_GETIMAGE(i); 04380 #ifndef GX_DOTNET 04381 bool st = gx_imagefromvariant(&i, variant._variant) ? true : false; 04382 if(st) { 04383 gx_unrefimage(_image); 04384 _image=i; 04385 } 04386 #else 04387 bool st = gx_imagefromvariant(&i, 04388 variant ? variant->_variant : 0 ) ? true : false; 04389 if(st) { 04390 gx_unrefimage(_image); 04391 _set_image(i); 04392 } 04393 #endif 04394 gxcondthrow(!st); 04395 return st; 04396 } 04397 04402 inline GX_INDIRECTION1(gxVariant) ToVariant(gxi32 varid) gxFuncThrowsError { 04403 04404 GX_GETIMAGE(i); 04405 gxVARIANT vari; 04406 bool st = gx_imagetovariant(i, varid, &vari) != 0; 04407 gxcondthrow(!st); 04408 if(!st) return GX_NULLPTR; 04409 GX_INDIRECTION(gxVariant,vr) = gxnew gxVariant(vari); 04410 gx_unrefvariant(vari); 04411 if(!vr){gxSystem::SetError((int)GX_ENUM_PATH(GX_ERROR_CODES) GX_ENOMEM);gxthrow;} 04412 return vr; 04413 } 04414 04415 #if !defined(GX_SWIG) && !defined(GX_DOTNET) 04416 04422 inline gxi32 TestImageFileFormat(const wchar_t *filename) gxFuncThrowsError { 04423 gxassert(filename); 04424 gxi32 fileformat; 04425 bool st = gx_testimagefileformat(filename, &fileformat) ? true : false; 04426 if(!st) { gxthrow; return 0; } 04427 return fileformat; 04428 } 04429 04436 inline gxi32 TestImageFileFormat(const char *filename) gxFuncThrowsError { 04437 gxassert(filename); 04438 gxi32 fileformat; 04439 bool st = gx_testimagefileformat(filename, &fileformat) ? true : false; 04440 if(!st) { gxthrow; return 0; } 04441 return fileformat; 04442 } 04443 04450 inline gxi32 TestImageFileFormat(const void *buffer, gxi32 buflen) gxFuncThrowsError { 04451 gxassert(buffer && buflen>0); 04452 gxi32 fileformat; 04453 bool st = gx_testimagefileformat(buffer, buflen, &fileformat) ? true : false; 04454 if(!st) { gxthrow; return 0; } 04455 return fileformat; 04456 } 04457 #else 04458 04463 inline gxi32 TestImageFileFormat(gxInData buffer) gxFuncThrowsError { 04464 GX_GETDATA(buffer); 04465 gxi32 fileformat; 04466 bool st = gx_testimagefileformat(GX_DATAPTR(buffer), GX_DATALEN(buffer), &fileformat) ? true : false; 04467 GX_FREEDATA(buffer); 04468 if(!st) { gxthrow; return 0; } 04469 return fileformat; 04470 } 04471 #endif 04472 04473 #ifdef GX_UNICODE 04474 04480 inline gxi32 TestImageFileFormat(gxInStr filename) gxFuncThrowsError { 04481 GX_GETSTRING(_filename, filename); 04482 gxi32 fileformat; 04483 bool st = gx_testimagefileformat(_filename, &fileformat) ? true : false; 04484 if(!st) { gxthrow; return 0; } 04485 return fileformat; 04486 } 04487 #endif 04488 04489 #ifdef GX_ASCII 04490 04496 inline gxi32 TestImageFileFormat(gxInAStr filename) gxFuncThrowsError { 04497 GX_GETASTRING(_filename, filename); 04498 gxi32 fileformat; 04499 bool st = gx_testimagefileformat(_filename, &fileformat) ? true : false; 04500 if(!st) { gxthrow; return 0; } 04501 return fileformat; 04502 } 04503 #endif 04504 04505 }; 04506 04507 #endif /* GX_EXT_MODULE )*/ 04508 04509 #endif /* NO_GX_CLASSES )*/ 04510 /******************************************************************************/ 04511 #ifdef GX_NAMESPACES 04512 } 04513 #endif 04514 #ifdef __BORLANDC__ 04515 #pragma warn .rch 04516 #endif 04517 /******************************************************************************/ 04518 #endif /* GX_IMAGE_INCL */ 04519 /******************************************************************************/