开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
GD.c
资源名称：netcam-1.2.tar.gz　[点击查看]
上传用户：qdrechuli
上传日期：2022-08-01
资源大小：917k
文件大小：34k
源码类别：

视频捕捉/采集

开发平台：

Visual C++

GD.c：源码内容
  1. /*
  2.  * This file was generated automatically by xsubpp version 1.9508 from the 
  3.  * contents of GD.xs. Do not edit this file, edit GD.xs instead.
  4.  *
  5.  * ANY CHANGES MADE HERE WILL BE LOST! 
  6.  *
  7.  */
  9. #line 1 "GD.xs"
  10. #include "EXTERN.h"
  11. #include "perl.h"
  12. #include "XSUB.h"
  13. #include "libgd/gd.h"
  14. #ifdef FCGI
  15.  #include <fcgi_stdio.h>
  16. #else
  17.  #ifdef USE_SFIO
  18.   #include <config.h>
  19.  #else
  20.   #include <stdio.h>
  21.  #endif
  22.  #include <perlio.h>
  23. #endif
  24. /* Copyright 1995, 1996, Lincoln D. Stein.  See accompanying README file for
  25. usage restrictions */
  27. static int
  28. not_here(s)
  29. char *s;
  30. {
  31.     croak("%s not implemented on this architecture", s);
  32.     return -1;
  33. }
  35. static double
  36. constant(name, arg)
  37. char *name;
  38. int arg;
  39. {
  40.     errno = 0;
  41.     switch (*name) {
  42.     case 'A':
  43. break;
  44.     case 'B':
  45. break;
  46.     case 'C':
  47. break;
  48.     case 'D':
  49. break;
  50.     case 'E':
  51. break;
  52.     case 'F':
  53. break;
  54.     case 'G':
  55. break;
  56.     case 'H':
  57. break;
  58.     case 'I':
  59. break;
  60.     case 'J':
  61. break;
  62.     case 'K':
  63. break;
  64.     case 'L':
  65. break;
  66.     case 'M':
  67. break;
  68.     case 'N':
  69. break;
  70.     case 'O':
  71. break;
  72.     case 'P':
  73. break;
  74.     case 'Q':
  75. break;
  76.     case 'R':
  77. break;
  78.     case 'S':
  79. break;
  80.     case 'T':
  81. break;
  82.     case 'U':
  83. break;
  84.     case 'V':
  85. break;
  86.     case 'W':
  87. break;
  88.     case 'X':
  89. break;
  90.     case 'Y':
  91. break;
  92.     case 'Z':
  93. break;
  94.     case 'a':
  95. break;
  96.     case 'b':
  97. break;
  98.     case 'c':
  99. break;
  100.     case 'd':
  101. break;
  102.     case 'e':
  103. break;
  104.     case 'f':
  105. break;
  106.     case 'g':
  107. if (strEQ(name, "gdBrushed"))
  108. #ifdef gdBrushed
  109.     return gdBrushed;
  110. #else
  111.     goto not_there;
  112. #endif
  113. if (strEQ(name, "gdDashSize"))
  114. #ifdef gdDashSize
  115.     return gdDashSize;
  116. #else
  117.     goto not_there;
  118. #endif
  119. if (strEQ(name, "gdMaxColors"))
  120. #ifdef gdMaxColors
  121.     return gdMaxColors;
  122. #else
  123.     goto not_there;
  124. #endif
  125. if (strEQ(name, "gdStyled"))
  126. #ifdef gdStyled
  127.     return gdStyled;
  128. #else
  129.     goto not_there;
  130. #endif
  131. if (strEQ(name, "gdStyledBrushed"))
  132. #ifdef gdStyledBrushed
  133.     return gdStyledBrushed;
  134. #else
  135.     goto not_there;
  136. #endif
  137. if (strEQ(name, "gdTiled"))
  138. #ifdef gdTiled
  139.     return gdTiled;
  140. #else
  141.     goto not_there;
  142. #endif
  143. if (strEQ(name, "gdTransparent"))
  144. #ifdef gdTransparent
  145.     return gdTransparent;
  146. #else
  147.     goto not_there;
  148. #endif
  149. break;
  150.     case 'h':
  151. break;
  152.     case 'i':
  153. break;
  154.     case 'j':
  155. break;
  156.     case 'k':
  157. break;
  158.     case 'l':
  159. break;
  160.     case 'm':
  161. break;
  162.     case 'n':
  163. break;
  164.     case 'o':
  165. break;
  166.     case 'p':
  167. break;
  168.     case 'q':
  169. break;
  170.     case 'r':
  171. break;
  172.     case 's':
  173. break;
  174.     case 't':
  175. break;
  176.     case 'u':
  177. break;
  178.     case 'v':
  179. break;
  180.     case 'w':
  181. break;
  182.     case 'x':
  183. break;
  184.     case 'y':
  185. break;
  186.     case 'z':
  187. break;
  188.     }
  189.     errno = EINVAL;
  190.     return 0;
  192. not_there:
  193.     errno = ENOENT;
  194.     return 0;
  195. }
  197. typedef gdImagePtr GD__Image;
  198. typedef gdFontPtr GD__Font;
  199. typedef PerlIO * InputStream;
  200. extern  gdFontPtr gdFontLarge;
  201. extern gdFontPtr gdFontSmall;
  202. extern gdFontPtr gdFontMediumBold;
  203. extern gdFontPtr gdFontTiny;
  205. #line 206 "GD.c"
  206. XS(XS_GD_constant)
  207. {
  208.     dXSARGS;
  209.     if (items != 2)
  210. Perl_croak(aTHX_ "Usage: GD::constant(name, arg)");
  211.     {
  212. char * name = (char *)SvPV(ST(0),PL_na);
  213. int arg = (int)SvIV(ST(1));
  214. double RETVAL;
  215. dXSTARG;
  217. RETVAL = constant(name, arg);
  218. XSprePUSH; PUSHn((double)RETVAL);
  219.     }
  220.     XSRETURN(1);
  221. }
  223. XS(XS_GD__Image_new)
  224. {
  225.     dXSARGS;
  226.     if (items < 0 || items > 3)
  227. Perl_croak(aTHX_ "Usage: GD::Image::new(packname="GD::Image", x=64, y=64)");
  228.     {
  229. char * packname;
  230. int x;
  231. int y;
  232. GD__Image RETVAL;
  234. if (items < 1)
  235.     packname = "GD::Image";
  236. else {
  237.     packname = (char *)SvPV(ST(0),PL_na);
  238. }
  240. if (items < 2)
  241.     x = 64;
  242. else {
  243.     x = (int)SvIV(ST(1));
  244. }
  246. if (items < 3)
  247.     y = 64;
  248. else {
  249.     y = (int)SvIV(ST(2));
  250. }
  251. #line 212 "GD.xs"
  252. {
  253. gdImagePtr theImage;
  254. theImage = gdImageCreate(x,y);
  255. RETVAL = theImage;
  256. }
  257. #line 258 "GD.c"
  258. ST(0) = sv_newmortal();
  259. sv_setref_pv(ST(0), "GD::Image", (void*)RETVAL);
  260.     }
  261.     XSRETURN(1);
  262. }
  264. XS(XS_GD__Image__newFromGif)
  265. {
  266.     dXSARGS;
  267.     if (items < 1 || items > 2)
  268. Perl_croak(aTHX_ "Usage: GD::Image::_newFromGif(packname="GD::Image", filehandle)");
  269.     {
  270. char * packname;
  271. InputStream filehandle = IoIFP(sv_2io(ST(1)));
  272. GD__Image RETVAL;
  274. if (items < 1)
  275.     packname = "GD::Image";
  276. else {
  277.     packname = (char *)SvPV(ST(0),PL_na);
  278. }
  279. #line 226 "GD.xs"
  280. RETVAL = gdImageCreateFromGif(filehandle);
  281. #line 282 "GD.c"
  282. ST(0) = sv_newmortal();
  283. sv_setref_pv(ST(0), "GD::Image", (void*)RETVAL);
  284.     }
  285.     XSRETURN(1);
  286. }
  288. XS(XS_GD__Image__newFromXbm)
  289. {
  290.     dXSARGS;
  291.     if (items < 1 || items > 2)
  292. Perl_croak(aTHX_ "Usage: GD::Image::_newFromXbm(packname="GD::Image", filehandle)");
  293.     {
  294. char * packname;
  295. InputStream filehandle = IoIFP(sv_2io(ST(1)));
  296. GD__Image RETVAL;
  298. if (items < 1)
  299.     packname = "GD::Image";
  300. else {
  301.     packname = (char *)SvPV(ST(0),PL_na);
  302. }
  303. #line 236 "GD.xs"
  304. RETVAL = gdImageCreateFromXbm(filehandle);
  305. #line 306 "GD.c"
  306. ST(0) = sv_newmortal();
  307. sv_setref_pv(ST(0), "GD::Image", (void*)RETVAL);
  308.     }
  309.     XSRETURN(1);
  310. }
  312. XS(XS_GD__Image__newFromGd)
  313. {
  314.     dXSARGS;
  315.     if (items < 1 || items > 2)
  316. Perl_croak(aTHX_ "Usage: GD::Image::_newFromGd(packname="GD::Image", filehandle)");
  317.     {
  318. char * packname;
  319. InputStream filehandle = IoIFP(sv_2io(ST(1)));
  320. GD__Image RETVAL;
  322. if (items < 1)
  323.     packname = "GD::Image";
  324. else {
  325.     packname = (char *)SvPV(ST(0),PL_na);
  326. }
  327. #line 246 "GD.xs"
  328. RETVAL = gdImageCreateFromGd(filehandle);
  329. #line 330 "GD.c"
  330. ST(0) = sv_newmortal();
  331. sv_setref_pv(ST(0), "GD::Image", (void*)RETVAL);
  332.     }
  333.     XSRETURN(1);
  334. }
  336. XS(XS_GD__Image_DESTROY)
  337. {
  338.     dXSARGS;
  339.     if (items != 1)
  340. Perl_croak(aTHX_ "Usage: GD::Image::DESTROY(image)");
  341.     {
  342. GD__Image image;
  344. if (SvROK(ST(0))) {
  345.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  346.     image = INT2PTR(GD__Image,tmp);
  347. }
  348. else
  349.     croak("image is not a reference");
  350. #line 256 "GD.xs"
  351. {
  352. gdImageDestroy(image);
  353. }
  354. #line 355 "GD.c"
  355.     }
  356.     XSRETURN_EMPTY;
  357. }
  359. XS(XS_GD__Image_gif)
  360. {
  361.     dXSARGS;
  362.     if (items != 1)
  363. Perl_croak(aTHX_ "Usage: GD::Image::gif(image)");
  364.     {
  365. GD__Image image;
  366. SV * RETVAL;
  368. if (sv_derived_from(ST(0), "GD::Image")) {
  369.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  370.     image = INT2PTR(GD__Image,tmp);
  371. }
  372. else
  373.     croak("image is not of type GD::Image");
  374. #line 265 "GD.xs"
  375.   {
  376. void*         data;
  377. int           size;
  378. data = gdImageGifPtr(image,&size);
  379. RETVAL = newSVpv((char*) data,size);
  380. free(data);
  381.   }
  382. #line 383 "GD.c"
  383. ST(0) = RETVAL;
  384. sv_2mortal(ST(0));
  385.     }
  386.     XSRETURN(1);
  387. }
  389. XS(XS_GD__Image_gd)
  390. {
  391.     dXSARGS;
  392.     if (items != 1)
  393. Perl_croak(aTHX_ "Usage: GD::Image::gd(image)");
  394.     {
  395. GD__Image image;
  396. SV * RETVAL;
  398. if (sv_derived_from(ST(0), "GD::Image")) {
  399.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  400.     image = INT2PTR(GD__Image,tmp);
  401. }
  402. else
  403.     croak("image is not of type GD::Image");
  404. #line 280 "GD.xs"
  405.   {
  406. void*         data;
  407. int           size;
  408. data = gdImageGdPtr(image,&size);
  409. RETVAL = newSVpv((char*) data,size);
  410. free(data);
  411.   }
  412. #line 413 "GD.c"
  413. ST(0) = RETVAL;
  414. sv_2mortal(ST(0));
  415.     }
  416.     XSRETURN(1);
  417. }
  419. XS(XS_GD__Image_transparent)
  420. {
  421.     dXSARGS;
  422.     if (items < 1)
  423. Perl_croak(aTHX_ "Usage: GD::Image::transparent(image, ...)");
  424.     {
  425. GD__Image image;
  426. int RETVAL;
  427. dXSTARG;
  429. if (sv_derived_from(ST(0), "GD::Image")) {
  430.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  431.     image = INT2PTR(GD__Image,tmp);
  432. }
  433. else
  434.     croak("image is not of type GD::Image");
  435. #line 295 "GD.xs"
  436. {
  437. int color;
  438. if (items > 1) {
  439. color=(int)SvIV(ST(1));
  440. gdImageColorTransparent(image,color);
  441. }
  442. RETVAL = gdImageGetTransparent(image);
  443. }
  444. #line 445 "GD.c"
  445. XSprePUSH; PUSHi((IV)RETVAL);
  446.     }
  447.     XSRETURN(1);
  448. }
  450. XS(XS_GD__Image_getBounds)
  451. {
  452.     dXSARGS;
  453.     if (items != 1)
  454. Perl_croak(aTHX_ "Usage: GD::Image::getBounds(image)");
  455.     SP -= items;
  456.     {
  457. GD__Image image;
  459. if (sv_derived_from(ST(0), "GD::Image")) {
  460.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  461.     image = INT2PTR(GD__Image,tmp);
  462. }
  463. else
  464.     croak("image is not of type GD::Image");
  465. #line 311 "GD.xs"
  466. {
  467. int sx,sy;
  468. sx = gdImageSX(image);
  469. sy = gdImageSY(image);
  470. EXTEND(sp,2);
  471. PUSHs(sv_2mortal(newSViv(sx)));
  472. PUSHs(sv_2mortal(newSViv(sy)));
  473. }
  474. #line 475 "GD.c"
  475. PUTBACK;
  476. return;
  477.     }
  478. }
  480. XS(XS_GD__Image_rgb)
  481. {
  482.     dXSARGS;
  483.     if (items != 2)
  484. Perl_croak(aTHX_ "Usage: GD::Image::rgb(image, color)");
  485.     SP -= items;
  486.     {
  487. GD__Image image;
  488. int color = (int)SvIV(ST(1));
  489. int RETVAL;
  490. dXSTARG;
  492. if (sv_derived_from(ST(0), "GD::Image")) {
  493.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  494.     image = INT2PTR(GD__Image,tmp);
  495. }
  496. else
  497.     croak("image is not of type GD::Image");
  498. #line 326 "GD.xs"
  499. {
  500. int r,g,b;
  501. r = gdImageRed(image,color);
  502. g = gdImageGreen(image,color);
  503. b = gdImageBlue(image,color);
  504. EXTEND(sp,3);
  505. PUSHs(sv_2mortal(newSViv(r)));
  506. PUSHs(sv_2mortal(newSViv(g)));
  507. PUSHs(sv_2mortal(newSViv(b)));
  508. }
  509. #line 510 "GD.c"
  510. PUTBACK;
  511. return;
  512.     }
  513. }
  515. XS(XS_GD__Image_boundsSafe)
  516. {
  517.     dXSARGS;
  518.     if (items != 3)
  519. Perl_croak(aTHX_ "Usage: GD::Image::boundsSafe(image, x, y)");
  520.     {
  521. GD__Image image;
  522. int x = (int)SvIV(ST(1));
  523. int y = (int)SvIV(ST(2));
  524. int RETVAL;
  525. dXSTARG;
  527. if (sv_derived_from(ST(0), "GD::Image")) {
  528.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  529.     image = INT2PTR(GD__Image,tmp);
  530. }
  531. else
  532.     croak("image is not of type GD::Image");
  533. #line 344 "GD.xs"
  534. {
  535. RETVAL=gdImageBoundsSafe(image,x,y);
  536. }
  537. #line 538 "GD.c"
  538. XSprePUSH; PUSHi((IV)RETVAL);
  539.     }
  540.     XSRETURN(1);
  541. }
  543. XS(XS_GD__Image_getPixel)
  544. {
  545.     dXSARGS;
  546.     if (items != 3)
  547. Perl_croak(aTHX_ "Usage: GD::Image::getPixel(image, x, y)");
  548.     {
  549. GD__Image image;
  550. int x = (int)SvIV(ST(1));
  551. int y = (int)SvIV(ST(2));
  552. int RETVAL;
  553. dXSTARG;
  555. if (sv_derived_from(ST(0), "GD::Image")) {
  556.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  557.     image = INT2PTR(GD__Image,tmp);
  558. }
  559. else
  560.     croak("image is not of type GD::Image");
  561. #line 357 "GD.xs"
  562. {
  563. RETVAL=gdImageGetPixel(image,x,y);
  564. }
  565. #line 566 "GD.c"
  566. XSprePUSH; PUSHi((IV)RETVAL);
  567.     }
  568.     XSRETURN(1);
  569. }
  571. XS(XS_GD__Image_setPixel)
  572. {
  573.     dXSARGS;
  574.     if (items != 4)
  575. Perl_croak(aTHX_ "Usage: GD::Image::setPixel(image, x, y, color)");
  576.     {
  577. GD__Image image;
  578. int x = (int)SvIV(ST(1));
  579. int y = (int)SvIV(ST(2));
  580. int color = (int)SvIV(ST(3));
  582. if (sv_derived_from(ST(0), "GD::Image")) {
  583.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  584.     image = INT2PTR(GD__Image,tmp);
  585. }
  586. else
  587.     croak("image is not of type GD::Image");
  588. #line 371 "GD.xs"
  589. {
  590. gdImageSetPixel(image,x,y,color);
  591. }
  592. #line 593 "GD.c"
  593.     }
  594.     XSRETURN_EMPTY;
  595. }
  597. XS(XS_GD__Image_line)
  598. {
  599.     dXSARGS;
  600.     if (items != 6)
  601. Perl_croak(aTHX_ "Usage: GD::Image::line(image, x1, y1, x2, y2, color)");
  602.     {
  603. GD__Image image;
  604. int x1 = (int)SvIV(ST(1));
  605. int y1 = (int)SvIV(ST(2));
  606. int x2 = (int)SvIV(ST(3));
  607. int y2 = (int)SvIV(ST(4));
  608. int color = (int)SvIV(ST(5));
  610. if (sv_derived_from(ST(0), "GD::Image")) {
  611.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  612.     image = INT2PTR(GD__Image,tmp);
  613. }
  614. else
  615.     croak("image is not of type GD::Image");
  616. #line 385 "GD.xs"
  617. {
  618. gdImageLine(image,x1,y1,x2,y2,color);
  619. }
  620. #line 621 "GD.c"
  621.     }
  622.     XSRETURN_EMPTY;
  623. }
  625. XS(XS_GD__Image_dashedLine)
  626. {
  627.     dXSARGS;
  628.     if (items != 6)
  629. Perl_croak(aTHX_ "Usage: GD::Image::dashedLine(image, x1, y1, x2, y2, color)");
  630.     {
  631. GD__Image image;
  632. int x1 = (int)SvIV(ST(1));
  633. int y1 = (int)SvIV(ST(2));
  634. int x2 = (int)SvIV(ST(3));
  635. int y2 = (int)SvIV(ST(4));
  636. int color = (int)SvIV(ST(5));
  638. if (sv_derived_from(ST(0), "GD::Image")) {
  639.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  640.     image = INT2PTR(GD__Image,tmp);
  641. }
  642. else
  643.     croak("image is not of type GD::Image");
  644. #line 399 "GD.xs"
  645. {
  646. gdImageDashedLine(image,x1,y1,x2,y2,color);
  647. }
  648. #line 649 "GD.c"
  649.     }
  650.     XSRETURN_EMPTY;
  651. }
  653. XS(XS_GD__Image_openPolygon)
  654. {
  655.     dXSARGS;
  656.     if (items != 3)
  657. Perl_croak(aTHX_ "Usage: GD::Image::openPolygon(image, poly, color)");
  658.     {
  659. GD__Image image;
  660. SV * poly = ST(1);
  661. int color = (int)SvIV(ST(2));
  663. if (sv_derived_from(ST(0), "GD::Image")) {
  664.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  665.     image = INT2PTR(GD__Image,tmp);
  666. }
  667. else
  668.     croak("image is not of type GD::Image");
  669. #line 410 "GD.xs"
  670. {
  671. dSP ;
  672. int length,count ;
  673. int x,y,i ;
  674. gdPointPtr polyptr;
  676. ENTER ;
  677. SAVETMPS ;
  678. PUSHMARK(sp) ;
  679. XPUSHs(poly) ;
  680. PUTBACK ;
  681. count = perl_call_method("length",G_SCALAR) ;
  682. SPAGAIN ;
  683. if (count != 1)
  684. croak("Didn't get a single result from GD::Poly::length() call.n");
  685. length = POPi ;
  686. PUTBACK ;
  687. FREETMPS ;
  688. LEAVE ;
  690. polyptr = (gdPointPtr)safemalloc(sizeof(gdPoint)*length);
  691. if (polyptr == NULL)
  692. croak("safemalloc() returned NULL in GD::Image::poly().n");
  694. for (i=0;i<length;i++) {
  695. ENTER ;
  696. SAVETMPS ;
  697. PUSHMARK(sp) ;
  698. XPUSHs(poly) ;
  699. XPUSHs(sv_2mortal(newSViv(i))) ;
  700. PUTBACK ;
  701. count = perl_call_method("getPt",G_ARRAY) ;
  702. SPAGAIN ;
  703. if (count != 2)
  704. croak("Didn't get a single result from GD::Poly::length() call.n");
  705. y = POPi ;
  706. x = POPi ;
  707. PUTBACK ;
  708. FREETMPS ;
  709. LEAVE ;
  711. polyptr[i].x = x;
  712. polyptr[i].y = y;
  713. }
  715. gdImageOpenPolygon(image,polyptr,length,color);
  716. safefree((char*) polyptr);
  717. }
  718. #line 719 "GD.c"
  719.     }
  720.     XSRETURN_EMPTY;
  721. }
  723. XS(XS_GD__Image_filledPolygon)
  724. {
  725.     dXSARGS;
  726.     if (items != 3)
  727. Perl_croak(aTHX_ "Usage: GD::Image::filledPolygon(image, poly, color)");
  728.     {
  729. GD__Image image;
  730. SV * poly = ST(1);
  731. int color = (int)SvIV(ST(2));
  733. if (sv_derived_from(ST(0), "GD::Image")) {
  734.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  735.     image = INT2PTR(GD__Image,tmp);
  736. }
  737. else
  738.     croak("image is not of type GD::Image");
  739. #line 466 "GD.xs"
  740. {
  741. dSP ;
  742. int length,count ;
  743. int x,y,i ;
  744. gdPointPtr polyptr;
  746. ENTER ;
  747. SAVETMPS ;
  748. PUSHMARK(sp) ;
  749. XPUSHs(poly) ;
  750. PUTBACK ;
  751. count = perl_call_method("length",G_SCALAR) ;
  752. SPAGAIN ;
  753. if (count != 1)
  754. croak("Didn't get a single result from GD::Poly::length() call.n");
  755. length = POPi ;
  756. PUTBACK ;
  757. FREETMPS ;
  758. LEAVE ;
  760. polyptr = (gdPointPtr)safemalloc(sizeof(gdPoint)*length);
  761. if (polyptr == NULL)
  762. croak("safemalloc() returned NULL in GD::Image::poly().n");
  764. for (i=0;i<length;i++) {
  765. ENTER ;
  766. SAVETMPS ;
  767. PUSHMARK(sp) ;
  768. XPUSHs(poly) ;
  769. XPUSHs(sv_2mortal(newSViv(i))) ;
  770. PUTBACK ;
  771. count = perl_call_method("getPt",G_ARRAY) ;
  772. SPAGAIN ;
  773. if (count != 2)
  774. croak("Didn't get a single result from GD::Poly::length() call.n");
  775. y = POPi ;
  776. x = POPi ;
  777. PUTBACK ;
  778. FREETMPS ;
  779. LEAVE ;
  781. polyptr[i].x = x;
  782. polyptr[i].y = y;
  783. }
  785. gdImageFilledPolygon(image,polyptr,length,color);
  786. safefree((char*) polyptr);
  787. }
  788. #line 789 "GD.c"
  789.     }
  790.     XSRETURN_EMPTY;
  791. }
  793. XS(XS_GD__Image_rectangle)
  794. {
  795.     dXSARGS;
  796.     if (items != 6)
  797. Perl_croak(aTHX_ "Usage: GD::Image::rectangle(image, x1, y1, x2, y2, color)");
  798.     {
  799. GD__Image image;
  800. int x1 = (int)SvIV(ST(1));
  801. int y1 = (int)SvIV(ST(2));
  802. int x2 = (int)SvIV(ST(3));
  803. int y2 = (int)SvIV(ST(4));
  804. int color = (int)SvIV(ST(5));
  806. if (sv_derived_from(ST(0), "GD::Image")) {
  807.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  808.     image = INT2PTR(GD__Image,tmp);
  809. }
  810. else
  811.     croak("image is not of type GD::Image");
  812. #line 525 "GD.xs"
  813. {
  814. gdImageRectangle(image,x1,y1,x2,y2,color);
  815. }
  816. #line 817 "GD.c"
  817.     }
  818.     XSRETURN_EMPTY;
  819. }
  821. XS(XS_GD__Image_filledRectangle)
  822. {
  823.     dXSARGS;
  824.     if (items != 6)
  825. Perl_croak(aTHX_ "Usage: GD::Image::filledRectangle(image, x1, y1, x2, y2, color)");
  826.     {
  827. GD__Image image;
  828. int x1 = (int)SvIV(ST(1));
  829. int y1 = (int)SvIV(ST(2));
  830. int x2 = (int)SvIV(ST(3));
  831. int y2 = (int)SvIV(ST(4));
  832. int color = (int)SvIV(ST(5));
  834. if (sv_derived_from(ST(0), "GD::Image")) {
  835.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  836.     image = INT2PTR(GD__Image,tmp);
  837. }
  838. else
  839.     croak("image is not of type GD::Image");
  840. #line 539 "GD.xs"
  841. {
  842. gdImageFilledRectangle(image,x1,y1,x2,y2,color);
  843. }
  844. #line 845 "GD.c"
  845.     }
  846.     XSRETURN_EMPTY;
  847. }
  849. XS(XS_GD__Image_arc)
  850. {
  851.     dXSARGS;
  852.     if (items != 8)
  853. Perl_croak(aTHX_ "Usage: GD::Image::arc(image, cx, cy, w, h, s, e, color)");
  854.     {
  855. GD__Image image;
  856. int cx = (int)SvIV(ST(1));
  857. int cy = (int)SvIV(ST(2));
  858. int w = (int)SvIV(ST(3));
  859. int h = (int)SvIV(ST(4));
  860. int s = (int)SvIV(ST(5));
  861. int e = (int)SvIV(ST(6));
  862. int color = (int)SvIV(ST(7));
  864. if (sv_derived_from(ST(0), "GD::Image")) {
  865.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  866.     image = INT2PTR(GD__Image,tmp);
  867. }
  868. else
  869.     croak("image is not of type GD::Image");
  870. #line 555 "GD.xs"
  871. {
  872. gdImageArc(image,cx,cy,w,h,s,e,color);
  873. }
  874. #line 875 "GD.c"
  875.     }
  876.     XSRETURN_EMPTY;
  877. }
  879. XS(XS_GD__Image_fillToBorder)
  880. {
  881.     dXSARGS;
  882.     if (items != 5)
  883. Perl_croak(aTHX_ "Usage: GD::Image::fillToBorder(image, x, y, border, color)");
  884.     {
  885. GD__Image image;
  886. int x = (int)SvIV(ST(1));
  887. int y = (int)SvIV(ST(2));
  888. int border = (int)SvIV(ST(3));
  889. int color = (int)SvIV(ST(4));
  891. if (sv_derived_from(ST(0), "GD::Image")) {
  892.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  893.     image = INT2PTR(GD__Image,tmp);
  894. }
  895. else
  896.     croak("image is not of type GD::Image");
  897. #line 568 "GD.xs"
  898. {
  899. gdImageFillToBorder(image,x,y,border,color);
  900. }
  901. #line 902 "GD.c"
  902.     }
  903.     XSRETURN_EMPTY;
  904. }
  906. XS(XS_GD__Image_fill)
  907. {
  908.     dXSARGS;
  909.     if (items != 4)
  910. Perl_croak(aTHX_ "Usage: GD::Image::fill(image, x, y, color)");
  911.     {
  912. GD__Image image;
  913. int x = (int)SvIV(ST(1));
  914. int y = (int)SvIV(ST(2));
  915. int color = (int)SvIV(ST(3));
  917. if (sv_derived_from(ST(0), "GD::Image")) {
  918.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  919.     image = INT2PTR(GD__Image,tmp);
  920. }
  921. else
  922.     croak("image is not of type GD::Image");
  923. #line 580 "GD.xs"
  924. {
  925. gdImageFill(image,x,y,color);
  926. }
  927. #line 928 "GD.c"
  928.     }
  929.     XSRETURN_EMPTY;
  930. }
  932. XS(XS_GD__Image_setBrush)
  933. {
  934.     dXSARGS;
  935.     if (items != 2)
  936. Perl_croak(aTHX_ "Usage: GD::Image::setBrush(image, brush)");
  937.     {
  938. GD__Image image;
  939. GD__Image brush;
  941. if (sv_derived_from(ST(0), "GD::Image")) {
  942.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  943.     image = INT2PTR(GD__Image,tmp);
  944. }
  945. else
  946.     croak("image is not of type GD::Image");
  948. if (sv_derived_from(ST(1), "GD::Image")) {
  949.     IV tmp = SvIV((SV*)SvRV(ST(1)));
  950.     brush = INT2PTR(GD__Image,tmp);
  951. }
  952. else
  953.     croak("brush is not of type GD::Image");
  954. #line 590 "GD.xs"
  955. {
  956. gdImageSetBrush(image,brush);
  957. }
  958. #line 959 "GD.c"
  959.     }
  960.     XSRETURN_EMPTY;
  961. }
  963. XS(XS_GD__Image_setTile)
  964. {
  965.     dXSARGS;
  966.     if (items != 2)
  967. Perl_croak(aTHX_ "Usage: GD::Image::setTile(image, tile)");
  968.     {
  969. GD__Image image;
  970. GD__Image tile;
  972. if (sv_derived_from(ST(0), "GD::Image")) {
  973.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  974.     image = INT2PTR(GD__Image,tmp);
  975. }
  976. else
  977.     croak("image is not of type GD::Image");
  979. if (sv_derived_from(ST(1), "GD::Image")) {
  980.     IV tmp = SvIV((SV*)SvRV(ST(1)));
  981.     tile = INT2PTR(GD__Image,tmp);
  982. }
  983. else
  984.     croak("tile is not of type GD::Image");
  985. #line 600 "GD.xs"
  986. {
  987. gdImageSetTile(image,tile);
  988. }
  989. #line 990 "GD.c"
  990.     }
  991.     XSRETURN_EMPTY;
  992. }
  994. XS(XS_GD__Image_setStyle)
  995. {
  996.     dXSARGS;
  997.     if (items < 1)
  998. Perl_croak(aTHX_ "Usage: GD::Image::setStyle(image, ...)");
  999.     {
  1000. GD__Image image;
  1002. if (sv_derived_from(ST(0), "GD::Image")) {
  1003.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1004.     image = INT2PTR(GD__Image,tmp);
  1005. }
  1006. else
  1007.     croak("image is not of type GD::Image");
  1008. #line 609 "GD.xs"
  1009. {
  1010. int *style;
  1011. int i;
  1013. if (items < 2)
  1014. return;
  1015. style = (int*) safemalloc(sizeof(int)*(items-1));
  1016. if (style == NULL)
  1017. croak("malloc returned NULL at setStyle().n");
  1018. for(i=1;i<items;i++) {
  1019. style[i-1]=(int)SvIV(ST(i));
  1020. }
  1021. gdImageSetStyle(image,style,items-1);
  1022. safefree((char*) style);
  1023. }
  1024. #line 1025 "GD.c"
  1025.     }
  1026.     XSRETURN_EMPTY;
  1027. }
  1029. XS(XS_GD__Image_colorAllocate)
  1030. {
  1031.     dXSARGS;
  1032.     if (items != 4)
  1033. Perl_croak(aTHX_ "Usage: GD::Image::colorAllocate(image, r, g, b)");
  1034.     {
  1035. GD__Image image;
  1036. int r = (int)SvIV(ST(1));
  1037. int g = (int)SvIV(ST(2));
  1038. int b = (int)SvIV(ST(3));
  1039. int RETVAL;
  1040. dXSTARG;
  1042. if (sv_derived_from(ST(0), "GD::Image")) {
  1043.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1044.     image = INT2PTR(GD__Image,tmp);
  1045. }
  1046. else
  1047.     croak("image is not of type GD::Image");
  1048. #line 633 "GD.xs"
  1049. {
  1050. RETVAL = gdImageColorAllocate(image,r,g,b);
  1051. }
  1052. #line 1053 "GD.c"
  1053. XSprePUSH; PUSHi((IV)RETVAL);
  1054.     }
  1055.     XSRETURN(1);
  1056. }
  1058. XS(XS_GD__Image_colorClosest)
  1059. {
  1060.     dXSARGS;
  1061.     if (items != 4)
  1062. Perl_croak(aTHX_ "Usage: GD::Image::colorClosest(image, r, g, b)");
  1063.     {
  1064. GD__Image image;
  1065. int r = (int)SvIV(ST(1));
  1066. int g = (int)SvIV(ST(2));
  1067. int b = (int)SvIV(ST(3));
  1068. int RETVAL;
  1069. dXSTARG;
  1071. if (sv_derived_from(ST(0), "GD::Image")) {
  1072.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1073.     image = INT2PTR(GD__Image,tmp);
  1074. }
  1075. else
  1076.     croak("image is not of type GD::Image");
  1077. #line 647 "GD.xs"
  1078. {
  1079. RETVAL = gdImageColorClosest(image,r,g,b);
  1080. }
  1081. #line 1082 "GD.c"
  1082. XSprePUSH; PUSHi((IV)RETVAL);
  1083.     }
  1084.     XSRETURN(1);
  1085. }
  1087. XS(XS_GD__Image_colorExact)
  1088. {
  1089.     dXSARGS;
  1090.     if (items != 4)
  1091. Perl_croak(aTHX_ "Usage: GD::Image::colorExact(image, r, g, b)");
  1092.     {
  1093. GD__Image image;
  1094. int r = (int)SvIV(ST(1));
  1095. int g = (int)SvIV(ST(2));
  1096. int b = (int)SvIV(ST(3));
  1097. int RETVAL;
  1098. dXSTARG;
  1100. if (sv_derived_from(ST(0), "GD::Image")) {
  1101.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1102.     image = INT2PTR(GD__Image,tmp);
  1103. }
  1104. else
  1105.     croak("image is not of type GD::Image");
  1106. #line 661 "GD.xs"
  1107. {
  1108. RETVAL = gdImageColorExact(image,r,g,b);
  1109. }
  1110. #line 1111 "GD.c"
  1111. XSprePUSH; PUSHi((IV)RETVAL);
  1112.     }
  1113.     XSRETURN(1);
  1114. }
  1116. XS(XS_GD__Image_colorsTotal)
  1117. {
  1118.     dXSARGS;
  1119.     if (items != 1)
  1120. Perl_croak(aTHX_ "Usage: GD::Image::colorsTotal(image)");
  1121.     {
  1122. GD__Image image;
  1123. int RETVAL;
  1124. dXSTARG;
  1126. if (sv_derived_from(ST(0), "GD::Image")) {
  1127.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1128.     image = INT2PTR(GD__Image,tmp);
  1129. }
  1130. else
  1131.     croak("image is not of type GD::Image");
  1132. #line 672 "GD.xs"
  1133. {
  1134. RETVAL = gdImageColorsTotal(image);
  1135. }
  1136. #line 1137 "GD.c"
  1137. XSprePUSH; PUSHi((IV)RETVAL);
  1138.     }
  1139.     XSRETURN(1);
  1140. }
  1142. XS(XS_GD__Image_interlaced)
  1143. {
  1144.     dXSARGS;
  1145.     if (items < 1)
  1146. Perl_croak(aTHX_ "Usage: GD::Image::interlaced(image, ...)");
  1147.     {
  1148. GD__Image image;
  1149. int RETVAL;
  1150. dXSTARG;
  1152. if (sv_derived_from(ST(0), "GD::Image")) {
  1153.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1154.     image = INT2PTR(GD__Image,tmp);
  1155. }
  1156. else
  1157.     croak("image is not of type GD::Image");
  1158. #line 684 "GD.xs"
  1159. {
  1160. if (items > 1) {
  1161. if (SvOK(ST(1)))
  1162. gdImageInterlace(image,1);
  1163. else
  1164. gdImageInterlace(image,0);
  1165. }
  1166. RETVAL = gdImageGetInterlaced(image);
  1167. }
  1168. #line 1169 "GD.c"
  1169. XSprePUSH; PUSHi((IV)RETVAL);
  1170.     }
  1171.     XSRETURN(1);
  1172. }
  1174. XS(XS_GD__Image_colorDeallocate)
  1175. {
  1176.     dXSARGS;
  1177.     if (items != 2)
  1178. Perl_croak(aTHX_ "Usage: GD::Image::colorDeallocate(image, color)");
  1179.     {
  1180. GD__Image image;
  1181. int color = (int)SvIV(ST(1));
  1183. if (sv_derived_from(ST(0), "GD::Image")) {
  1184.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1185.     image = INT2PTR(GD__Image,tmp);
  1186. }
  1187. else
  1188.     croak("image is not of type GD::Image");
  1189. #line 702 "GD.xs"
  1190. {
  1191. gdImageColorDeallocate(image,color);
  1192. }
  1193. #line 1194 "GD.c"
  1194.     }
  1195.     XSRETURN_EMPTY;
  1196. }
  1198. XS(XS_GD__Image_copy)
  1199. {
  1200.     dXSARGS;
  1201.     if (items != 8)
  1202. Perl_croak(aTHX_ "Usage: GD::Image::copy(destination, source, dstX, dstY, srcX, srcY, w, h)");
  1203.     {
  1204. GD__Image destination;
  1205. GD__Image source;
  1206. int dstX = (int)SvIV(ST(2));
  1207. int dstY = (int)SvIV(ST(3));
  1208. int srcX = (int)SvIV(ST(4));
  1209. int srcY = (int)SvIV(ST(5));
  1210. int w = (int)SvIV(ST(6));
  1211. int h = (int)SvIV(ST(7));
  1213. if (sv_derived_from(ST(0), "GD::Image")) {
  1214.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1215.     destination = INT2PTR(GD__Image,tmp);
  1216. }
  1217. else
  1218.     croak("destination is not of type GD::Image");
  1220. if (sv_derived_from(ST(1), "GD::Image")) {
  1221.     IV tmp = SvIV((SV*)SvRV(ST(1)));
  1222.     source = INT2PTR(GD__Image,tmp);
  1223. }
  1224. else
  1225.     croak("source is not of type GD::Image");
  1226. #line 718 "GD.xs"
  1227. {
  1228. gdImageCopy(destination,source,dstX,dstY,srcX,srcY,w,h);
  1229. }
  1230. #line 1231 "GD.c"
  1231.     }
  1232.     XSRETURN_EMPTY;
  1233. }
  1235. XS(XS_GD__Image_copyResized)
  1236. {
  1237.     dXSARGS;
  1238.     if (items != 10)
  1239. Perl_croak(aTHX_ "Usage: GD::Image::copyResized(destination, source, dstX, dstY, srcX, srcY, destW, destH, srcW, srcH)");
  1240.     {
  1241. GD__Image destination;
  1242. GD__Image source;
  1243. int dstX = (int)SvIV(ST(2));
  1244. int dstY = (int)SvIV(ST(3));
  1245. int srcX = (int)SvIV(ST(4));
  1246. int srcY = (int)SvIV(ST(5));
  1247. int destW = (int)SvIV(ST(6));
  1248. int destH = (int)SvIV(ST(7));
  1249. int srcW = (int)SvIV(ST(8));
  1250. int srcH = (int)SvIV(ST(9));
  1252. if (sv_derived_from(ST(0), "GD::Image")) {
  1253.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1254.     destination = INT2PTR(GD__Image,tmp);
  1255. }
  1256. else
  1257.     croak("destination is not of type GD::Image");
  1259. if (sv_derived_from(ST(1), "GD::Image")) {
  1260.     IV tmp = SvIV((SV*)SvRV(ST(1)));
  1261.     source = INT2PTR(GD__Image,tmp);
  1262. }
  1263. else
  1264.     croak("source is not of type GD::Image");
  1265. #line 736 "GD.xs"
  1266. {
  1267. gdImageCopyResized(destination,source,dstX,dstY,srcX,srcY,destW,destH,srcW,srcH);
  1268. }
  1269. #line 1270 "GD.c"
  1270.     }
  1271.     XSRETURN_EMPTY;
  1272. }
  1274. XS(XS_GD__Image_char)
  1275. {
  1276.     dXSARGS;
  1277.     if (items != 6)
  1278. Perl_croak(aTHX_ "Usage: GD::Image::char(image, font, x, y, c, color)");
  1279.     {
  1280. GD__Image image;
  1281. GD__Font font;
  1282. int x = (int)SvIV(ST(2));
  1283. int y = (int)SvIV(ST(3));
  1284. char * c = (char *)SvPV(ST(4),PL_na);
  1285. int color = (int)SvIV(ST(5));
  1287. if (sv_derived_from(ST(0), "GD::Image")) {
  1288.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1289.     image = INT2PTR(GD__Image,tmp);
  1290. }
  1291. else
  1292.     croak("image is not of type GD::Image");
  1294. if (sv_derived_from(ST(1), "GD::Font")) {
  1295.     IV tmp = SvIV((SV*)SvRV(ST(1)));
  1296.     font = INT2PTR(GD__Font,tmp);
  1297. }
  1298. else
  1299.     croak("font is not of type GD::Font");
  1300. #line 750 "GD.xs"
  1301. {
  1302. gdImageChar(image,font,x,y,*c,color);
  1303. }
  1304. #line 1305 "GD.c"
  1305.     }
  1306.     XSRETURN_EMPTY;
  1307. }
  1309. XS(XS_GD__Image_charUp)
  1310. {
  1311.     dXSARGS;
  1312.     if (items != 6)
  1313. Perl_croak(aTHX_ "Usage: GD::Image::charUp(image, font, x, y, c, color)");
  1314.     {
  1315. GD__Image image;
  1316. GD__Font font;
  1317. int x = (int)SvIV(ST(2));
  1318. int y = (int)SvIV(ST(3));
  1319. char * c = (char *)SvPV(ST(4),PL_na);
  1320. int color = (int)SvIV(ST(5));
  1322. if (sv_derived_from(ST(0), "GD::Image")) {
  1323.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1324.     image = INT2PTR(GD__Image,tmp);
  1325. }
  1326. else
  1327.     croak("image is not of type GD::Image");
  1329. if (sv_derived_from(ST(1), "GD::Font")) {
  1330.     IV tmp = SvIV((SV*)SvRV(ST(1)));
  1331.     font = INT2PTR(GD__Font,tmp);
  1332. }
  1333. else
  1334.     croak("font is not of type GD::Font");
  1335. #line 764 "GD.xs"
  1336. {
  1337. gdImageCharUp(image,font,x,y,*c,color);
  1338. }
  1339. #line 1340 "GD.c"
  1340.     }
  1341.     XSRETURN_EMPTY;
  1342. }
  1344. XS(XS_GD__Image_string)
  1345. {
  1346.     dXSARGS;
  1347.     if (items != 6)
  1348. Perl_croak(aTHX_ "Usage: GD::Image::string(image, font, x, y, s, color)");
  1349.     {
  1350. GD__Image image;
  1351. GD__Font font;
  1352. int x = (int)SvIV(ST(2));
  1353. int y = (int)SvIV(ST(3));
  1354. char * s = (char *)SvPV(ST(4),PL_na);
  1355. int color = (int)SvIV(ST(5));
  1357. if (sv_derived_from(ST(0), "GD::Image")) {
  1358.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1359.     image = INT2PTR(GD__Image,tmp);
  1360. }
  1361. else
  1362.     croak("image is not of type GD::Image");
  1364. if (sv_derived_from(ST(1), "GD::Font")) {
  1365.     IV tmp = SvIV((SV*)SvRV(ST(1)));
  1366.     font = INT2PTR(GD__Font,tmp);
  1367. }
  1368. else
  1369.     croak("font is not of type GD::Font");
  1370. #line 778 "GD.xs"
  1371. {
  1372. gdImageString(image,font,x,y,s,color);
  1373. }
  1374. #line 1375 "GD.c"
  1375.     }
  1376.     XSRETURN_EMPTY;
  1377. }
  1379. XS(XS_GD__Image_stringUp)
  1380. {
  1381.     dXSARGS;
  1382.     if (items != 6)
  1383. Perl_croak(aTHX_ "Usage: GD::Image::stringUp(image, font, x, y, s, color)");
  1384.     {
  1385. GD__Image image;
  1386. GD__Font font;
  1387. int x = (int)SvIV(ST(2));
  1388. int y = (int)SvIV(ST(3));
  1389. char * s = (char *)SvPV(ST(4),PL_na);
  1390. int color = (int)SvIV(ST(5));
  1392. if (sv_derived_from(ST(0), "GD::Image")) {
  1393.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1394.     image = INT2PTR(GD__Image,tmp);
  1395. }
  1396. else
  1397.     croak("image is not of type GD::Image");
  1399. if (sv_derived_from(ST(1), "GD::Font")) {
  1400.     IV tmp = SvIV((SV*)SvRV(ST(1)));
  1401.     font = INT2PTR(GD__Font,tmp);
  1402. }
  1403. else
  1404.     croak("font is not of type GD::Font");
  1405. #line 792 "GD.xs"
  1406. {
  1407. gdImageStringUp(image,font,x,y,s,color);
  1408. }
  1409. #line 1410 "GD.c"
  1410.     }
  1411.     XSRETURN_EMPTY;
  1412. }
  1414. XS(XS_GD__Font_Small)
  1415. {
  1416.     dXSARGS;
  1417.     if (items < 0 || items > 1)
  1418. Perl_croak(aTHX_ "Usage: GD::Font::Small(packname="GD::Font")");
  1419.     {
  1420. char * packname;
  1421. GD__Font RETVAL;
  1423. if (items < 1)
  1424.     packname = "GD::Font";
  1425. else {
  1426.     packname = (char *)SvPV(ST(0),PL_na);
  1427. }
  1428. #line 803 "GD.xs"
  1429. {
  1430. RETVAL = gdFontSmall;
  1431. }
  1432. #line 1433 "GD.c"
  1433. ST(0) = sv_newmortal();
  1434. sv_setref_pv(ST(0), "GD::Font", (void*)RETVAL);
  1435.     }
  1436.     XSRETURN(1);
  1437. }
  1439. XS(XS_GD__Font_Large)
  1440. {
  1441.     dXSARGS;
  1442.     if (items < 0 || items > 1)
  1443. Perl_croak(aTHX_ "Usage: GD::Font::Large(packname="GD::Font")");
  1444.     {
  1445. char * packname;
  1446. GD__Font RETVAL;
  1448. if (items < 1)
  1449.     packname = "GD::Font";
  1450. else {
  1451.     packname = (char *)SvPV(ST(0),PL_na);
  1452. }
  1453. #line 814 "GD.xs"
  1454. {
  1455. RETVAL = gdFontLarge;
  1456. }
  1457. #line 1458 "GD.c"
  1458. ST(0) = sv_newmortal();
  1459. sv_setref_pv(ST(0), "GD::Font", (void*)RETVAL);
  1460.     }
  1461.     XSRETURN(1);
  1462. }
  1464. XS(XS_GD__Font_MediumBold)
  1465. {
  1466.     dXSARGS;
  1467.     if (items < 0 || items > 1)
  1468. Perl_croak(aTHX_ "Usage: GD::Font::MediumBold(packname="GD::Font")");
  1469.     {
  1470. char * packname;
  1471. GD__Font RETVAL;
  1473. if (items < 1)
  1474.     packname = "GD::Font";
  1475. else {
  1476.     packname = (char *)SvPV(ST(0),PL_na);
  1477. }
  1478. #line 825 "GD.xs"
  1479. {
  1480. RETVAL = gdFontMediumBold;
  1481. }
  1482. #line 1483 "GD.c"
  1483. ST(0) = sv_newmortal();
  1484. sv_setref_pv(ST(0), "GD::Font", (void*)RETVAL);
  1485.     }
  1486.     XSRETURN(1);
  1487. }
  1489. XS(XS_GD__Font_Tiny)
  1490. {
  1491.     dXSARGS;
  1492.     if (items < 0 || items > 1)
  1493. Perl_croak(aTHX_ "Usage: GD::Font::Tiny(packname="GD::Font")");
  1494.     {
  1495. char * packname;
  1496. GD__Font RETVAL;
  1498. if (items < 1)
  1499.     packname = "GD::Font";
  1500. else {
  1501.     packname = (char *)SvPV(ST(0),PL_na);
  1502. }
  1503. #line 836 "GD.xs"
  1504. {
  1505. RETVAL = gdFontTiny;
  1506. }
  1507. #line 1508 "GD.c"
  1508. ST(0) = sv_newmortal();
  1509. sv_setref_pv(ST(0), "GD::Font", (void*)RETVAL);
  1510.     }
  1511.     XSRETURN(1);
  1512. }
  1514. XS(XS_GD__Font_nchars)
  1515. {
  1516.     dXSARGS;
  1517.     if (items != 1)
  1518. Perl_croak(aTHX_ "Usage: GD::Font::nchars(font)");
  1519.     {
  1520. GD__Font font;
  1521. int RETVAL;
  1522. dXSTARG;
  1524. if (sv_derived_from(ST(0), "GD::Font")) {
  1525.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1526.     font = INT2PTR(GD__Font,tmp);
  1527. }
  1528. else
  1529.     croak("font is not of type GD::Font");
  1530. #line 847 "GD.xs"
  1531. {
  1532. RETVAL = font->nchars;
  1533. }
  1534. #line 1535 "GD.c"
  1535. XSprePUSH; PUSHi((IV)RETVAL);
  1536.     }
  1537.     XSRETURN(1);
  1538. }
  1540. XS(XS_GD__Font_offset)
  1541. {
  1542.     dXSARGS;
  1543.     if (items != 1)
  1544. Perl_croak(aTHX_ "Usage: GD::Font::offset(font)");
  1545.     {
  1546. GD__Font font;
  1547. int RETVAL;
  1548. dXSTARG;
  1550. if (sv_derived_from(ST(0), "GD::Font")) {
  1551.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1552.     font = INT2PTR(GD__Font,tmp);
  1553. }
  1554. else
  1555.     croak("font is not of type GD::Font");
  1556. #line 858 "GD.xs"
  1557. {
  1558. RETVAL = font->offset;
  1559. }
  1560. #line 1561 "GD.c"
  1561. XSprePUSH; PUSHi((IV)RETVAL);
  1562.     }
  1563.     XSRETURN(1);
  1564. }
  1566. XS(XS_GD__Font_width)
  1567. {
  1568.     dXSARGS;
  1569.     if (items != 1)
  1570. Perl_croak(aTHX_ "Usage: GD::Font::width(font)");
  1571.     {
  1572. GD__Font font;
  1573. int RETVAL;
  1574. dXSTARG;
  1576. if (sv_derived_from(ST(0), "GD::Font")) {
  1577.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1578.     font = INT2PTR(GD__Font,tmp);
  1579. }
  1580. else
  1581.     croak("font is not of type GD::Font");
  1582. #line 869 "GD.xs"
  1583. {
  1584. RETVAL = font->w;
  1585. }
  1586. #line 1587 "GD.c"
  1587. XSprePUSH; PUSHi((IV)RETVAL);
  1588.     }
  1589.     XSRETURN(1);
  1590. }
  1592. XS(XS_GD__Font_height)
  1593. {
  1594.     dXSARGS;
  1595.     if (items != 1)
  1596. Perl_croak(aTHX_ "Usage: GD::Font::height(font)");
  1597.     {
  1598. GD__Font font;
  1599. int RETVAL;
  1600. dXSTARG;
  1602. if (sv_derived_from(ST(0), "GD::Font")) {
  1603.     IV tmp = SvIV((SV*)SvRV(ST(0)));
  1604.     font = INT2PTR(GD__Font,tmp);
  1605. }
  1606. else
  1607.     croak("font is not of type GD::Font");
  1608. #line 880 "GD.xs"
  1609. {
  1610. RETVAL = font->h;
  1611. }
  1612. #line 1613 "GD.c"
  1613. XSprePUSH; PUSHi((IV)RETVAL);
  1614.     }
  1615.     XSRETURN(1);
  1616. }
  1618. #ifdef __cplusplus
  1619. extern "C"
  1620. #endif
  1621. XS(boot_GD)
  1622. {
  1623.     dXSARGS;
  1624.     char* file = __FILE__;
  1626.     XS_VERSION_BOOTCHECK ;
  1628.         newXS("GD::constant", XS_GD_constant, file);
  1629.         newXSproto("GD::Image::new", XS_GD__Image_new, file, "$;$$");
  1630.         newXSproto("GD::Image::_newFromGif", XS_GD__Image__newFromGif, file, "$$");
  1631.         newXSproto("GD::Image::_newFromXbm", XS_GD__Image__newFromXbm, file, "$$");
  1632.         newXSproto("GD::Image::_newFromGd", XS_GD__Image__newFromGd, file, "$$");
  1633.         newXSproto("GD::Image::DESTROY", XS_GD__Image_DESTROY, file, "$");
  1634.         newXSproto("GD::Image::gif", XS_GD__Image_gif, file, "$");
  1635.         newXSproto("GD::Image::gd", XS_GD__Image_gd, file, "$");
  1636.         newXSproto("GD::Image::transparent", XS_GD__Image_transparent, file, "$;$");
  1637.         newXSproto("GD::Image::getBounds", XS_GD__Image_getBounds, file, "$");
  1638.         newXSproto("GD::Image::rgb", XS_GD__Image_rgb, file, "$$");
  1639.         newXSproto("GD::Image::boundsSafe", XS_GD__Image_boundsSafe, file, "$$$");
  1640.         newXSproto("GD::Image::getPixel", XS_GD__Image_getPixel, file, "$$$");
  1641.         newXSproto("GD::Image::setPixel", XS_GD__Image_setPixel, file, "$$$");
  1642.         newXSproto("GD::Image::line", XS_GD__Image_line, file, "$$$$$$");
  1643.         newXSproto("GD::Image::dashedLine", XS_GD__Image_dashedLine, file, "$$$$$$");
  1644.         newXSproto("GD::Image::openPolygon", XS_GD__Image_openPolygon, file, "$$$");
  1645.         newXSproto("GD::Image::filledPolygon", XS_GD__Image_filledPolygon, file, "$$$");
  1646.         newXSproto("GD::Image::rectangle", XS_GD__Image_rectangle, file, "$$$$$$");
  1647.         newXSproto("GD::Image::filledRectangle", XS_GD__Image_filledRectangle, file, "$$$$$$");
  1648.         newXSproto("GD::Image::arc", XS_GD__Image_arc, file, "$$$$$$$$");
  1649.         newXSproto("GD::Image::fillToBorder", XS_GD__Image_fillToBorder, file, "$$$$$");
  1650.         newXSproto("GD::Image::fill", XS_GD__Image_fill, file, "$$$$");
  1651.         newXSproto("GD::Image::setBrush", XS_GD__Image_setBrush, file, "$$");
  1652.         newXSproto("GD::Image::setTile", XS_GD__Image_setTile, file, "$$");
  1653.         newXSproto("GD::Image::setStyle", XS_GD__Image_setStyle, file, "$;$");
  1654.         newXSproto("GD::Image::colorAllocate", XS_GD__Image_colorAllocate, file, "$$$$");
  1655.         newXSproto("GD::Image::colorClosest", XS_GD__Image_colorClosest, file, "$$$$");
  1656.         newXSproto("GD::Image::colorExact", XS_GD__Image_colorExact, file, "$$$$");
  1657.         newXSproto("GD::Image::colorsTotal", XS_GD__Image_colorsTotal, file, "$");
  1658.         newXSproto("GD::Image::interlaced", XS_GD__Image_interlaced, file, "$;$");
  1659.         newXSproto("GD::Image::colorDeallocate", XS_GD__Image_colorDeallocate, file, "$$");
  1660.         newXSproto("GD::Image::copy", XS_GD__Image_copy, file, "$$$$$$$$");
  1661.         newXSproto("GD::Image::copyResized", XS_GD__Image_copyResized, file, "$$$$$$$$$$");
  1662.         newXSproto("GD::Image::char", XS_GD__Image_char, file, "$$$$$$");
  1663.         newXSproto("GD::Image::charUp", XS_GD__Image_charUp, file, "$$$$$$");
  1664.         newXSproto("GD::Image::string", XS_GD__Image_string, file, "$$$$$$");
  1665.         newXSproto("GD::Image::stringUp", XS_GD__Image_stringUp, file, "$$$$$$");
  1666.         newXSproto("GD::Font::Small", XS_GD__Font_Small, file, "$");
  1667.         newXSproto("GD::Font::Large", XS_GD__Font_Large, file, "$");
  1668.         newXSproto("GD::Font::MediumBold", XS_GD__Font_MediumBold, file, "$");
  1669.         newXSproto("GD::Font::Tiny", XS_GD__Font_Tiny, file, "$");
  1670.         newXSproto("GD::Font::nchars", XS_GD__Font_nchars, file, "$");
  1671.         newXSproto("GD::Font::offset", XS_GD__Font_offset, file, "$");
  1672.         newXSproto("GD::Font::width", XS_GD__Font_width, file, "$");
  1673.         newXSproto("GD::Font::height", XS_GD__Font_height, file, "$");
  1674.     XSRETURN_YES;
  1675. }