[
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "The GD Library",
    "CATEGORY": "Document",
    "ONELINER": "Read me file for GD Library",
    "DESCRIPTION": "HBGD is basically a wrapper of Thomas Boutell's GD Library version 2.x.\nGD Library is a powerful graphic library very useful especially under CGI environment.\n\nHBGD actually contains almost all GD functions, more a set of functions that extends original\nlibrary and a set of classes that make easier to work with this library.\n\nThomas Boutell's GD library actually supports these graphic formats:\nPNG, JPEG, GIF, Animated GIF, GD, GD2, WBMP, XBM, XPM\nWBMP is Wireless Bitmap, not Windows Bitmap, and it is used for WAP. It is a B&W bitmap.\n\nHBGD actually supports PNG, JPEG, GIF, GD, WBMP\nThe other Animated GIF, GD2, XBM and XPM are not wrapped actually.\n\nUsing this library you can, as a little example:\n- create an image in memory, true color or with a 256 colors palette;\n- load and save an image of above formats and convert it to another supported format;\n- draw dots, lines, dashed lines, polygons, rectangles, arcs, circles and ellipses;\n- fill with colors;\n- draw with brushes;\n- check a point or part or full image with a lot of query functions;\n- draw characters and words with internal fonts or using TrueType fonts;\n- write strings on a base line or on a circle line and with any angle degree;\n- copy, resize and rotate part or full image;\n\nand, over this, some functions to clone, crop, zoom, rotate outside and inside.\n\nThe prefix for all functions is GD (i.e. gdImageCreate() )\n\nYou can use directly all API functions or TGD class.\n\nNOTE: Not all functions are wrapped.\n",
    "SEEALSO": "GDImage Class, GDChart Class"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageCreate()",
    "CATEGORY": "hbgd",
    "ONELINER": "Create a palette-based image in memory with no more that 256 colors.",
    "SYNTAX": "gdImageCreate( <nPixelWidth>, <nPixelHeight> ) --> pImage",
    "ARGUMENTS": "<nPixelWidth>  - image width\n<nPixelHeight> - image height",
    "RETURNS": "<pImage>       - Image pointer",
    "DESCRIPTION": "gdImageCreate() creates an empty image in memory.\nThis image has no more than 256 colors.\n\ngdImageCreate() returns an image pointer or NIL if unable to create the image.\n",
    "EXAMPLES": "LOCAL pImage := gdImageCreate( 64, 64 )\n\n// Use image here",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreateTrueColor()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageCreateTrueColor()",
    "CATEGORY": "hbgd",
    "ONELINER": "Create a true color image in memory.",
    "SYNTAX": "gdImageCreateTrueColor( <nPixelWidth>, <nPixelHeight> ) --> pImage",
    "ARGUMENTS": "<nPixelWidth>  - image width\n<nPixelHeight> - image height",
    "RETURNS": "<pImage>       - Image pointer",
    "DESCRIPTION": "gdImageCreateTrueColor() creates an empty image in memory.\nThis image has true colors.\n\ngdImageCreateTrueColor() returns an image pointer or NIL if unable to create the image.\n",
    "EXAMPLES": "LOCAL pImage := gdImageCreateTrueColor( 64, 64 )\n\n// Use image here",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageCreateFromJpeg()",
    "CATEGORY": "hbgd",
    "ONELINER": "Load a JPEG image file.",
    "SYNTAX": "gdImageCreateFromJpeg( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> pImage",
    "ARGUMENTS": "<cFile>        - Image file name\n<nHandle>      - File handle\n<pPointer>     - Memory image pointer\n<nSize>        - Image size",
    "RETURNS": "<pImage>       - Image pointer",
    "DESCRIPTION": "gdImageCreateFromJpeg() creates a JPEG image from a file or a handle or another image in memory.\n\nYou can use one of 3 syntax:\n```\npImage := gdImageCreateFromJpeg( \"myimage.jpg\" )\n```\nor\n```\npImage := gdImageCreateFromJpeg( nFileHandle, nSize )\n```\nor\n```\npImage := gdImageCreateFromJpeg( pMemoryImagePtr, nSize )\n```\nthe <pImage> pointer returned will be not NIL if successful and will contains a memory pointer\nto the JPEG image.\n\nHBGD uses it's own memory to manage an image, so it is important to use this function.\n",
    "EXAMPLES": "LOCAL pImage := gdImageCreateFromJpeg( \"myimage.jpg\" )\n\n// Use image here",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageCreateTrueColor(), gdImageCreateFromGif(), gdImageCreateFromPng(), gdImageCreateFromGD(), gdImageCreateFromWBmp()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageCreateFromGif()",
    "CATEGORY": "hbgd",
    "ONELINER": "Load a GIF image file.",
    "SYNTAX": "gdImageCreateFromGif( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> pImage",
    "ARGUMENTS": "<cFile>        - Image file name\n<nHandle>      - File handle\n<pPointer>     - Memory image pointer\n<nSize>        - Image size",
    "RETURNS": "<pImage>       - Image pointer",
    "DESCRIPTION": "gdImageCreateFromGif() creates a GIF image from a file or a handle or another image in memory.\n\nYou can use one of 3 syntax:\n```\npImage := gdImageCreateFromGif( \"myimage.gif\" )\n```\nor\n```\npImage := gdImageCreateFromGif( nFileHandle, nSize )\n```\nor\n```\npImage := gdImageCreateFromGif( pMemoryImagePtr, nSize )\n```\nthe <pImage> pointer returned will be not NIL if successful and will contains a memory pointer\nto the gif image.\n\nHBGD uses it's own memory to manage an image, so it is important to use this function.\n",
    "EXAMPLES": "LOCAL pImage := gdImageCreateFromGif( \"myimage.gif\" )\n\n// Use image here",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageCreateTrueColor(), gdImageCreateFromJpeg(), gdImageCreateFromPng(), gdImageCreateFromGD(), gdImageCreateFromWBmp()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageCreateFromPng()",
    "CATEGORY": "hbgd",
    "ONELINER": "Load a PNG image file.",
    "SYNTAX": "gdImageCreateFromPng( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> pImage",
    "ARGUMENTS": "<cFile>        - Image file name\n<nHandle>      - File handle\n<pPointer>     - Memory image pointer\n<nSize>        - Image size",
    "RETURNS": "<pImage>       - Image pointer",
    "DESCRIPTION": "gdImageCreateFromPng() creates a PNG image from a file or a handle or another image in memory.\n\nYou can use one of 3 syntax:\n```\npImage := gdImageCreateFromPng( \"myimage.png\" )\n```\nor\n```\npImage := gdImageCreateFromPng( nFileHandle, nSize )\n```\nor\n```\npImage := gdImageCreateFromPng( pMemoryImagePtr, nSize )\n```\nthe <pImage> pointer returned will be not NIL if successful and will contains a memory pointer\nto the png image.\n\nHBGD uses it's own memory to manage an image, so it is important to use this function.\n",
    "EXAMPLES": "LOCAL pImage := gdImageCreateFromPng( \"myimage.png\" )\n\n// Use image here",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageCreateTrueColor(), gdImageCreateFromJpeg(), gdImageCreateFromGif(), gdImageCreateFromGD(), gdImageCreateFromWBmp()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageCreateFromGD()",
    "CATEGORY": "hbgd",
    "ONELINER": "Load a GD image file.",
    "SYNTAX": "gdImageCreateFromGD( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> pImage",
    "ARGUMENTS": "<cFile>        - Image file name\n<nHandle>      - File handle\n<pPointer>     - Memory image pointer\n<nSize>        - Image size",
    "RETURNS": "<pImage>       - Image pointer",
    "DESCRIPTION": "gdImageCreateFromGD() creates a GD image from a file or a handle or another image in memory.\n\nYou can use one of 3 syntax:\n```\npImage := gdImageCreateFromGD( \"myimage.gd\" )\n```\nor\n```\npImage := gdImageCreateFromGD( nFileHandle, nSize )\n```\nor\n```\npImage := gdImageCreateFromGD( pMemoryImagePtr, nSize )\n```\nthe <pImage> pointer returned will be not NIL if successful and will contains a memory pointer\nto the GD image.\n\nHBGD uses it's own memory to manage an image, so it is important to use this function.\n",
    "EXAMPLES": "LOCAL pImage := gdImageCreateFromGD( \"myimage.gd\" )\n\n// Use image here",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageCreateTrueColor(), gdImageCreateFromJpeg(), gdImageCreateFromGif(), gdImageCreateFromPng(), gdImageCreateFromWBmp()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageCreateFromWBmp()",
    "CATEGORY": "hbgd",
    "ONELINER": "Load a WBMP image file.",
    "SYNTAX": "gdImageCreateFromWBmp( <cFile> | <nHandle> | <pPointer> [, <nSize> ] ) --> pImage",
    "ARGUMENTS": "<cFile>        - Image file name\n<nHandle>      - File handle\n<pPointer>     - Memory image pointer\n<nSize>        - Image size",
    "RETURNS": "<pImage>       - Image pointer",
    "DESCRIPTION": "gdImageCreateFromWBmp() creates a WBMP image from a file or a handle or another image in memory.\n\nYou can use one of 3 syntax:\n```\npImage := gdImageCreateFromWBmp( \"myimage.wbmp\" )\n```\nor\n```\npImage := gdImageCreateFromWBmp( nFileHandle, nSize )\n```\nor\n```\npImage := gdImageCreateFromWBmp( pMemoryImagePtr, nSize )\n```\nthe <pImage> pointer returned will be not NIL if successful and will contains a memory pointer\nto the WBMP image.\n\nHBGD uses it's own memory to manage an image, so it is important to use this function.\n",
    "EXAMPLES": "LOCAL pImage := gdImageCreateFromWBmp( \"myimage.wbmp\" )\n\n// Use image here",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageCreateTrueColor(), gdImageCreateFromJpeg(), gdImageCreateFromGif(), gdImageCreateFromPng(), gdImageCreateFromGD()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageJpeg()",
    "CATEGORY": "hbgd",
    "ONELINER": "Save a JPEG image.",
    "SYNTAX": "gdImageJpeg( <pImage>, <cFile> | <nHandle> [, <nCompressionLevel> ] ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<cFile>        - Image file name\n<nHandle>      - File handle\n<nCompressionLevel> - a numeric value between 0=max compression and 95=min compression (best quality)\n                      default is -1=auto",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageJpeg() saves a JPEG image to a file or a handle.\n\nYou can use one of 2 syntax:\n```\ngdImageJpeg( pImage, \"myimage.jpg\" )\n```\nor\n```\ngdImageJpeg( pImage, nFileHandle )\n```",
    "EXAMPLES": "LOCAL pImage := gdImageCreateFromGif( \"myimage.gif\" )\n\n// Image conversion\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreateFromGif()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageGif()",
    "CATEGORY": "hbgd",
    "ONELINER": "Save a GIF image.",
    "SYNTAX": "gdImageGif( <pImage>, <cFile> | <nHandle> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<cFile>        - Image file name\n<nHandle>      - File handle",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageGif() saves a GIF image to a file or a handle.\n\nYou can use one of 2 syntax:\n```\ngdImageGif( pImage, \"myimage.gif\" )\n```\nor\n```\ngdImageGif( pImage, nFileHandle )\n```",
    "EXAMPLES": "LOCAL pImage := gdImageCreateFromJpeg( \"myimage.jpg\" )\n\n// Image conversion\ngdImageGif( pImage, \"myimage.gif\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreateFromJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImagePng()",
    "CATEGORY": "hbgd",
    "ONELINER": "Save a PNG image.",
    "SYNTAX": "gdImagePng( <pImage>, <cFile> | <nHandle> [, <nCompressionLevel> ] ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<cFile>        - Image file name\n<nHandle>      - File handle\n<nCompressionLevel> - a numeric value between 0=no compression and 9=max compression\n                      default is -1=auto",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImagePng() saves a PNG image to a file or a handle.\n\nYou can use one of 2 syntax:\n```\ngdImagePng( pImage, \"myimage.png\" )\n```\nor\n```\ngdImagePng( pImage, nFileHandle )\n```",
    "EXAMPLES": "LOCAL pImage := gdImageCreateFromGif( \"myimage.gif\" )\n\n// Image conversion\ngdImagePng( pImage, \"myimage.png\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreateFromGif()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageGD()",
    "CATEGORY": "hbgd",
    "ONELINER": "Save a GD image.",
    "SYNTAX": "gdImageGD( <pImage>, <cFile> | <nHandle> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<cFile>        - Image file name\n<nHandle>      - File handle",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageGD() saves a GD image to a file or a handle.\n\nYou can use one of 2 syntax:\n```\ngdImageGD( pImage, \"myimage.gd\" )\n```\nor\n```\ngdImageGD( pImage, nFileHandle )\n",
    "EXAMPLES": "LOCAL pImage := gdImageCreateFromGif( \"myimage.gif\" )\n\n// Image conversion\ngdImageGD( pImage, \"myimage.gd\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreateFromGif()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageWBmp()",
    "CATEGORY": "hbgd",
    "ONELINER": "Save a WBMP image.",
    "SYNTAX": "gdImageWBmp( <pImage>, <cFile> | <nHandle> [, <nFGcolor> ] ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<cFile>        - Image file name\n<nHandle>      - File handle\n<nFGcolor>     - foreground color value to be used as foreground, the others are background",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageWBmp() saves a WBMP image to a file or a handle.\n\nYou can use one of 2 syntax:\n```\ngdImageWBmp( pImage, \"myimage.wbmp\", nColor )\n```\nor\n```\ngdImagePng( pImage, nFileHandle, nColor )\n```",
    "EXAMPLES": "LOCAL pImage\nLOCAL white, black\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate background\nwhite := gdImageColorAllocate( pImage, 255, 255, 255 )\n\n// Allocate drawing color\nblack := gdImageColorAllocate( pImage, 0, 0, 0 )\n\n// Draw a rectangle\ngdImageRectangle( pImage, 0, 0, 99, 99, black )\n\n// Save the image with black as foreground color\ngdImageWBmp( pImage, \"myimage.wbmp\", black )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageRectangle(), gdImageColorAllocate()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageSetPixel()",
    "CATEGORY": "hbgd",
    "ONELINER": "Set a pixel to a particular color index.",
    "SYNTAX": "gdImageSetPixel( <pImage>, <x>, <y>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<x>            - Horizontal position\n<y>            - Vertical position\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageSetPixel() sets a pixel to a particular color index.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL white\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nwhite := gdImageColorAllocate( pImage, 255, 255, 255 )\n\n// Draw a pixel\ngdImageSetPixel( pImage, 50, 50, white )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageLine()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws a line between two end points (x1, y1 and x2, y2) with a particular color index.",
    "SYNTAX": "gdImageLine( <pImage>, <x1>, <y1>, <x2>, <y2>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<x1>           - 1st point horizontal position\n<y1>           - 1st point vertical position\n<x2>           - 2nd point horizontal position\n<y2>           - 2nd point vertical position\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageLine() Draws a line between two end points (x1, y1 and x2, y2)\nwith a particular color index.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draw a line\ngdImageLine( pImage, 10, 10, 90, 90, blue )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageDashedLine()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws a dashed line between two end points (x1, y1 and x2, y2) with a particular color index.",
    "SYNTAX": "gdImageDashedLine( <pImage>, <x1>, <y1>, <x2>, <y2>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<x1>           - 1st point horizontal position\n<y1>           - 1st point vertical position\n<x2>           - 2nd point horizontal position\n<y2>           - 2nd point vertical position\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageDashedLine() Draws a dashed line between two end points (x1, y1 and x2, y2)\nwith a particular color index.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draw a dashed line\ngdImageDashedLine( pImage, 10, 10, 90, 90, blue )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImagePolygon()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws a closed polygon with vertices (at least 3) with a particular color index.",
    "SYNTAX": "gdImagePolygon( <pImage>, <aVertices>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<aVertices>    - Array of point array { <x>, <y> } where\n                 <x> is horizontal position\n                 <y> is vertical position\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImagePolygon() Draws a closed polygon with vertices (at least 3) with a\nparticular color index.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue\nLOCAL aVertices := { ;\n   { 50,  0 }, ;\n   { 99, 99 }, ;\n   {  0, 99 } }\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draw a polygon\ngdImagePolygon( pImage, aVertices, blue )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageOpenPolygon()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws an open polygon with vertices (at least 3) with a particular color index.",
    "SYNTAX": "gdImageOpenPolygon( <pImage>, <aVertices>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<aVertices>    - Array of point array { <x>, <y> } where\n                 <x> is horizontal position\n                 <y> is vertical position\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageOpenPolygon() Draws an open polygon with vertices (at least 3) with a\nparticular color index. Unlike gdImagePolygon() the endpoints of the line sequence\nare not connected to close the polygon.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue\nLOCAL aVertices := { ;\n   { 50,  0 }, ;\n   { 99, 99 }, ;\n   {  0, 99 } }\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draws an open polygon\ngdImageOpenPolygon( pImage, aVertices, blue )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageRectangle()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws a rectangle with a particular color index.",
    "SYNTAX": "gdImageRectangle( <pImage>, <x1>, <y1>, <x2>, <y2>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<x1>           - upper left point horizontal position\n<y1>           - upper left point vertical position\n<x2>           - lower right point horizontal position\n<y2>           - lower right point vertical position\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageRectangle() draws a rectangle between 2 points with a\nparticular color index.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draw a rectangle\ngdImageRectangle( pImage, 10, 10, 50, 50, blue )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageFilledPolygon()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws a filled polygon with vertices (at least 3) with a particular color index.",
    "SYNTAX": "gdImageFilledPolygon( <pImage>, <aVertices>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<aVertices>    - Array of point array { <x>, <y> } where\n                 <x> is horizontal position\n                 <y> is vertical position\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageFilledPolygon() Draws a filled polygon with vertices (at least 3) with a\nparticular color index.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue\nLOCAL aVertices := { ;\n   { 50,  0 }, ;\n   { 99, 99 }, ;\n   {  0, 99 } }\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draw a filled polygon\ngdImageFilledPolygon( pImage, aVertices, blue )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageFilledRectangle()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws a filled rectangle with a particular color index.",
    "SYNTAX": "gdImageFilledRectangle( <pImage>, <x1>, <y1>, <x2>, <y2>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<x1>           - upper left point horizontal position\n<y1>           - upper left point vertical position\n<x2>           - lower right point horizontal position\n<y2>           - lower right point vertical position\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageFilledRectangle() draws a filled rectangle between 2 points with a\nparticular color index.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draw a filled rectangle\ngdImageFilledRectangle( pImage, 10, 10, 50, 50, blue )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageArc()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws a partial ellipse centered at a given point.",
    "SYNTAX": "gdImageArc( <pImage>, <cx>, <cy>, <w>, <h>, <s>, <e>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<cx>           - center point horizontal position\n<cy>           - center point vertical position\n<w>            - width\n<h>            - height\n<s>            - start degree\n<e>            - end degree\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageArc() is used to draw a partial ellipse centered at the given point,\nwith the specified width and height in pixels. The arc begins at the position\nin degrees specified by s and ends at the position specified by e.\nThe arc is drawn in the color specified by the last argument. A circle can be drawn\nby beginning from 0 degrees and ending at 360 degrees, with width and height being equal.\n<e> must be greater than <s>. Values greater than 360 are interpreted modulo 360.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draw an ellipse\ngdImageArc( pImage, 50, 25, 98, 48, 0, 360, blue )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageFilledArc()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws a partial filled ellipse centered at a given point.",
    "SYNTAX": "gdImageArc( <pImage>, <cx>, <cy>, <w>, <h>, <s>, <e>, <nColor>, <nStyle> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<cx>           - center point horizontal position\n<cy>           - center point vertical position\n<w>            - width\n<h>            - height\n<s>            - start degree\n<e>            - end degree\n<nColor>       - Color index\n<nStyle>       - fill style",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageFilledArc() is used to draw a partial ellipse centered at the given point,\nwith the specified width and height in pixels. The arc begins at the position\nin degrees specified by s and ends at the position specified by e.\nThe arc is drawn in the color specified by the last argument. A circle can be drawn\nby beginning from 0 degrees and ending at 360 degrees, with width and height being equal.\n<e> must be greater than <s>. Values greater than 360 are interpreted modulo 360.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n\nLast parameter <nStyle> is a bitwise OR of the following possibilities:\n\n<table-noheader>\ngdArc\ngdChord\ngdPie (synonym for gdArc)\ngdNoFill\ngdEdged\n</table>\n\n`gdArc` and `gdChord` are mutually exclusive;\n`gdChord` just connects the starting and ending angles with a straight line,\nwhile `gdArc` produces a rounded edge. `gdPie` is a synonym for `gdArc`.\n`gdNoFill` indicates that the arc or chord should be outlined, not filled.\n`gdEdged`, used together with `gdNoFill`, indicates that the beginning and ending\nangles should be connected to the center; this is a good way to outline\n(rather than fill) a 'pie slice'\n\nthese constants are defined in gd.ch\n",
    "EXAMPLES": "#include \"gd.ch\"\n\nLOCAL pImage\nLOCAL blue\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draw an ellipse\ngdImageFilledArc( pImage, 50, 25, 98, 48, 0, 360, blue, gdArc )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageFilledEllipse()",
    "CATEGORY": "hbgd",
    "ONELINER": "Draws a filled ellipse centered at a given point.",
    "SYNTAX": "gdImageFilledEllipse( <pImage>, <cx>, <cy>, <w>, <h>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<cx>           - center point horizontal position\n<cy>           - center point vertical position\n<w>            - width\n<h>            - height\n<nColor>       - Color index",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageFilledEllipse() is used to draw a filled ellipse centered at the given point,\nwith the specified width and height in pixels.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\n\n// Draw an ellipse\ngdImageFilledEllipse( pImage, 50, 25, 98, 48, blue )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageFillToBorder()",
    "CATEGORY": "hbgd",
    "ONELINER": "floods a portion of the image with the specified color.",
    "SYNTAX": "gdImageFillToBorder( <pImage>, <x>, <y>, <nBorder>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<x>            - start point horizontal position\n<y>            - start point vertical position\n<nBorder>      - Color index where fill stops\n<nColor>       - Color index of filling color",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageFillToBorder() floods a portion of the image with the specified color,\nbeginning at the specified point and stopping at the specified border color. For a way of\nflooding an area defined by the color of the starting point, see gdImageFill().\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue, red\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\nred  := gdImageColorAllocate( pImage, 255, 0, 0 )\n\n// Draw an ellipse\ngdImageArc( pImage, 50, 25, 98, 48, 0, 360, blue )\n\n// Fill the ellipse\ngdImageFillToBorder( pImage, 50, 50, blue, red )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg(), gdImageArc()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageFill()",
    "CATEGORY": "hbgd",
    "ONELINER": "floods a portion of the image with the specified color.",
    "SYNTAX": "gdImageFill( <pImage>, <x>, <y>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<x>            - start point horizontal position\n<y>            - start point vertical position\n<nColor>       - Color index of filling color",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageFill() floods a portion of the image with the specified color, beginning at the\nspecified point and flooding the surrounding region of the same color as the starting point.\nFor a way of flooding a region defined by a specific border color rather than by its interior\ncolor, see gdImageFillToBorder().\nThe fill color can be `gdTiled`, resulting in a tile fill using another image as the tile.\nHowever, the tile image cannot be transparent. If the image you wish to fill with has a\ntransparent color index, call gdImageTransparent() on the tile image and set the transparent\ncolor index to -1 to turn off its transparency.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "LOCAL pImage\nLOCAL blue, red\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\nred  := gdImageColorAllocate( pImage, 255, 0, 0 )\n\n// Draw an ellipse\ngdImageArc( pImage, 50, 25, 98, 48, 0, 360, blue )\n\n// Fill the ellipse\ngdImageFill( pImage, 50, 50, red )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg(), gdImageArc()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageSetAntiAliased()",
    "CATEGORY": "hbgd",
    "ONELINER": "specify the actual foreground color to be used when drawing anti-aliased lines.",
    "SYNTAX": "gdImageSetAntiAliased( <pImage>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<nColor>       - Color index of filling color",
    "RETURNS": "NIL",
    "DESCRIPTION": "\"Antialiasing\" is a process by which jagged edges associated with line drawing\ncan be reduced by blending the foreground color with an appropriate percentage of\nthe background, depending on how much of the pixel in question is actually within\nthe boundaries of the line being drawn. All line-drawing functions, such as gdImageLine(),\ngdImageOpenPolygon() and gdImagePolygon(), will draw anti-aliased lines if the special \"color\"\n`gdAntiAliased` constant is used when calling them.\n\ngdImageSetAntiAliased() is used to specify the actual foreground color to be used when drawing\nanti-aliased lines. You may set any color to be the foreground, however as of version 2.0.12\nan alpha channel component is not supported.\n\nAnti-aliased lines can be drawn on both true-color and palette-based images. However,\nattempts to draw anti-aliased lines on highly complex palette-based backgrounds may not give\nsatisfactory results, due to the limited number of colors available in the palette. Anti-aliased\nline-drawing on simple backgrounds should work well with palette-based images; otherwise create\nor fetch a true-color image instead.\n\nYou need not take any special action when you are finished with anti-aliased line drawing.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "#include \"gd.ch\"\n\nLOCAL pImage\nLOCAL blue, red\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\n/* Background color (first allocated) */\nblue := gdImageColorAllocate( pImage, 0, 0, 255 )\nred  := gdImageColorAllocate( pImage, 255, 0, 0 )\n\ngdImageSetAntiAliased( pImage, blue )\n\n// Draw a smooth line\ngdImageLine( pImage, 0, 0, 99, 9, gdAntiAliased )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg(), gdImageLine(), gdAntiAliased, gdImageSetAntiAliasedDontBlend()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageSetAntiAliasedDontBlend()",
    "CATEGORY": "hbgd",
    "ONELINER": "indicate the special color that the foreground should stand out more clearly against.",
    "SYNTAX": "gdImageSetAntiAliasedDontBlend( <pImage>, <nColor> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<nColor>       - Color index of filling color",
    "RETURNS": "NIL",
    "DESCRIPTION": "Normally, when drawing lines with the special `gdAntiAliased` \"color,\" blending with\nthe background to reduce jagged edges is the desired behavior. However, when it is\ndesired that lines not be blended with one particular color when it is encountered\nin the background, the gdImageSetAntiAliasedDontBlend() function can be used to indicate\nthe special color that the foreground should stand out more clearly against.\n\nTo set the color index you have to use gdImageColorAllocate() function.\n",
    "EXAMPLES": "#include \"gd.ch\"\n\nLOCAL pImage\nLOCAL black, white, blue\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color\n/* Background color (first allocated) */\nblack := gdImageColorAllocate( pImage, 0, 0, 0 )\nwhite := gdImageColorAllocate( pImage, 255, 255, 255 )\nblue  := gdImageColorAllocate( pImage, 0, 0, 255 )\n\ngdImageSetAntiAliased( pImage, blue )\n\n// The portion of the line that crosses this white rectangle will not be blended smoothly\ngdImageSetAntiAliasedDontBlend( pImage, white )\n\n// Draw a smooth line\ngdImageLine( pImage, 0, 0, 99, 9, gdAntiAliased )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg(), gdImageLine(), gdAntiAliased, gdImageSetAntiAliased()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageSetBrush()",
    "CATEGORY": "hbgd",
    "ONELINER": "A \"brush\" is an image used to draw wide, shaped strokes in another image.",
    "SYNTAX": "gdImageSetBrush( <pImage>, <pBrush> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<pBrush>       - Brush Image pointer",
    "RETURNS": "NIL",
    "DESCRIPTION": "A \"brush\" is an image used to draw wide, shaped strokes in another image.\nJust as a paintbrush is not a single point, a brush image need not be a single pixel.\nAny gd image can be used as a brush, and by setting the transparent color index of the\nbrush image with gdImageColorTransparent(), a brush of any shape can be created.\nAll line-drawing functions, such as gdImageLine(), gdImageOpenPolygon() and gdImagePolygon(),\nwill use the current brush if the special \"color\" `gdBrushed` or `gdStyledBrushed` is used\nwhen calling them.\ngdImageSetBrush() is used to specify the brush to be used in a particular image.\nYou can set any image to be the brush. If the brush image does not have the same color\nmap as the first image, any colors missing from the first image will be allocated.\nIf not enough colors can be allocated, the closest colors already available will be used.\nThis allows arbitrary PNGs to be used as brush images. It also means, however, that you\nshould not set a brush unless you will actually use it; if you set a rapid succession of\ndifferent brush images, you can quickly fill your color map, and the results will not be\noptimal.\n\nYou need not take any special action when you are finished with a brush. As for any other image.\nYou must not use the color `gdBrushed` if the current brush has been destroyed; you can of course\nset a new brush to replace it.\n",
    "EXAMPLES": "LOCAL pImage, pBrush\nLOCAL blue, red\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Open the brush PNG. For best results, portions of the brush that should be transparent\n// (i.e., not part of the brush shape) should have the transparent color index.\npBrush := gdImageCreateFromPng( \"mybrush.png\" )\n\n// Allocate color  (background color is the first allocate)\nblack := gdImageColorAllocate( pImage, 0, 0, 0 )\n\n// Set the brush\ngdImageSetBrush( pImage, pBrush )\n\n// Draw a line from the upper left corner to the lower\n// right corner using the brush.\ngdImageLine( pImage, 0, 0, 99, 99, gdBrushed )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg(), gdImageLine()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageSetTile()",
    "CATEGORY": "hbgd",
    "ONELINER": "A \"tile\" is an image used to fill an area with a repeated pattern.",
    "SYNTAX": "gdImageSetTile( <pImage>, <pTile> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<pTile>        - Tile Image pointer",
    "RETURNS": "NIL",
    "DESCRIPTION": "A \"tile\" is an image used to fill an area with a repeated pattern.\nAny gd image can be used as a tile, and by setting the transparent color index of\nthe tile image with gdImageColorTransparent(), a tile that allows certain parts of\nthe underlying area to shine through can be created. All region-filling functions,\nsuch as gdImageFill() and gdImageFilledPolygon(), will use the current tile if the special\n\"color\" `gdTiled` is used when calling them.\n\ngdImageSetTile() is used to specify the tile to be used in a particular image. You can\nset any image to be the tile. If the tile image does not have the same color map as\nthe first image, any colors missing from the first image will be allocated. If not\nenough colors can be allocated, the closest colors already available will be used.\nThis allows arbitrary PNGs to be used as tile images. It also means, however, that you\nshould not set a tile unless you will actually use it; if you set a rapid succession of\ndifferent tile images, you can quickly fill your color map, and the results will not be optimal.\n\nYou need not take any special action when you are finished with a tile. As for any other\nimage. You must not use the color `gdTiled` if the current tile has been destroyed;\nyou can of course set a new tile to replace it.\n",
    "EXAMPLES": "LOCAL pImage, pTile\nLOCAL blue, red\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Open the tile PNG. For best results, portions of the\n// tile that should be transparent (i.e., allowing the\n// background to shine through) should have the transparent\n// color index.\npTile := gdImageCreateFromPng( \"mytile.png\" )\n\n// Allocate color  (background color is the first allocate)\nblack := gdImageColorAllocate( pImage, 0, 0, 0 )\n\n// Set the tile\ngdImageSetTile( pImage, pTile )\n\n// Fill an area using the tile\ngdImageFilledRectangle( pImage, 25, 25, 75, 75, gdTiled )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg(), gdImageFilledRectangle()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageSetStyle()",
    "CATEGORY": "hbgd",
    "ONELINER": "set any desired series of colors to be repeated during the drawing of a line.",
    "SYNTAX": "gdImageSetStyle( <pImage>, <aStyle> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<aStyle>       - Array of colors and special colors used to \"style\" a line",
    "RETURNS": "NIL",
    "DESCRIPTION": "It is often desirable to draw dashed lines, dotted lines, and other variations\non a broken line. gdImageSetStyle() can be used to set any desired series of colors,\nincluding a special color that leaves the background intact, to be repeated during\nthe drawing of a line.\nTo use gdImageSetStyle(), create an array of integers and assign them the desired series\nof color values to be repeated. You can assign the special color value `gdTransparent`\nto indicate that the existing color should be left unchanged for that particular pixel\n(allowing a dashed line to be attractively drawn over an existing image).\n\nThen, to draw a line using the style, use the normal gdImageLine() function with the\nspecial color value `gdStyled`.\n\nThe style array is copied when you set the style, so you need not be concerned with\nkeeping the array around indefinitely. This should not break existing code that assumes\nstyles are not copied.\n\nYou can also combine styles and brushes to draw the brush image at intervals instead of\nin a continuous stroke. When creating a style for use with a brush, the style values are\ninterpreted differently: zero (0) indicates pixels at which the brush should not be drawn,\nwhile one (1) indicates pixels at which the brush should be drawn. To draw a styled,\nbrushed line, you must use the special color value `gdStyledBrushed`.\n",
    "EXAMPLES": "#include \"gd.ch\"\n\nLOCAL pImage, aStyleDotted := {}, aStyleDashed := {}\nLOCAL black, red\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color  (background color is the first allocate)\nblack := gdImageColorAllocate( pImage, 0, 0, 0 )\nred   := gdImageColorAllocate( pImage, 255, 0, 0 )\n\n// Set up dotted style. Leave every other pixel alone.\nAAdd( aStyleDotted, red )\nAAdd( aStyleDotted, gdTransparent )\n\n// Set up dashed style. Three on, three off.\nAAdd( aStyleDashed, red )\nAAdd( aStyleDashed, red )\nAAdd( aStyleDashed, red )\nAAdd( aStyleDashed, gdTransparent )\nAAdd( aStyleDashed, gdTransparent )\nAAdd( aStyleDashed, gdTransparent )\n\n// Set dotted style.\ngdImageSetStyle( pImage, aStyleDotted )\n\n// Draw a line from the upper left corner to the lower right corner.\ngdImageLine( pImage, 0, 0, 99, 99, gdStyled )\n\n// Now the dashed line.\ngdImageSetStyle( pImage, aStyleDashed )\ngdImageLine( pimage, 0, 99, 0, 99, gdStyled )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg(), gdImageLine()"
  },
  {
    "_COMPONENT": "hbgd",
    "_LANG": "en",
    "_DOCSOURCE": "./hbgd/doc/en/gdwrp.txt",
    "NAME": "gdImageSetThickness()",
    "CATEGORY": "hbgd",
    "ONELINER": "determines the width of lines drawn in pixels.",
    "SYNTAX": "gdImageSetThickness( <pImage>, <nThickness> ) --> NIL",
    "ARGUMENTS": "<pImage>       - Image pointer\n<nThickness>   - width of line in pixel",
    "RETURNS": "NIL",
    "DESCRIPTION": "gdImageSetThickness() determines the width of lines drawn by the gdImageLine(),\ngdImagePolygon(), gdImageOpenPolygon() and related functions, in pixels.\n",
    "EXAMPLES": "#include \"gd.ch\"\n\nLOCAL pImage\nLOCAL black, white\n\n// Create an image in memory\npImage := gdImageCreate( 100, 100 )\n\n// Allocate color  (background color is the first allocate)\nblack := gdImageColorAllocate( pImage, 0, 0, 0 )\nwhite := gdImageColorAllocate( pImage, 255, 255, 255 )\n\n// Set thickness.\ngdImageSetThickness( pImage, 4 )\n\n// Draw a fat line from the upper left corner to the lower right corner.\ngdImageLine( pImage, 0, 0, 99, 99, white )\n\n// Save the image\ngdImageJpeg( pImage, \"myimage.jpg\" )",
    "STATUS": "R",
    "COMPLIANCE": "NA",
    "PLATFORMS": "All",
    "SEEALSO": "gdImageCreate(), gdImageColorAllocate(), gdImageJpeg(), gdImageLine()"
  }
]
