Unit GRX; { Converted by Sven Hilscher eMail sven@rufus.lan-ks.de from Headerfile grx20.h } {* ** grx20.h ---- GRX 2.x API functions and data structure declarations ** ** Copyright (c) 1995 Csaba Biegl, 820 Stirrup Dr, Nashville, TN 37221 ** [e-mail: csaba@vuse.vanderbilt.edu] ** ** This file is part of the GRX graphics library. ** ** The GRX graphics library is free software; you can redistribute it ** and/or modify it under some conditions; see the "copying.grx" file ** for details. ** ** This library is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *} { Define this if you want to use the Linux console version. (Ignored on non-Linux systems.) } {.$define LINUX_CONSOLE} {$gnu-pascal,I-} {$ifdef __DJGPP__} {$L grx20} {$elif defined (__MINGW32__)} {$L grx20} {$elif defined (_WIN32)} {$L grxW32, vfs.c, user32, gdi32} {$elif defined (linux) and defined (LINUX_CONSOLE)} {$L grx20, vga} {$else} {$L grx20X, X11} {$endif} { Uncomment those of the following libraries that you need } {.$L tiff} {.$L jpeg} {.$L png} {.$L z} {.$L socket} {$ifdef _WIN32} {$gpc-main="GRXMain"} {$endif} Interface Type MemPtr = ^Char; GrColor = Integer (32); (* color and operation type, must be 32bit *) GrColorPtr = ^GrColor; GrColors = array [0 .. MaxInt div SizeOf (GrColor) - 1] of GrColor; GrColorsPtr = ^GrColors; { This definition is compatible with the grx definition 'int pts[][2]' used to define polygons } PointType = record X, Y : Integer; end; Const (* these are the supported configurations: *) GRX_VERSION_TCC_8086_DOS = 1; (* also works with BCC *) GRX_VERSION_GCC_386_GO32 = 2; (* DJGPP *) GRX_VERSION_GCC_386_LINUX = 3; (* the real stuff *) GRX_VERSION_GENERIC_X11 = 4; (* generic X11 version *) GRX_VERSION_WATCOM_DOS4GW = 5; (* Watcom C++ 11.0 32 Bit *) { * available video modes (for 'GrSetMode') } GR_unknown_mode = -1; { initial state } { ============= modes which clear the video memory ============= } GR_80_25_text = 0; { Extra parameters for GrSetMode: } GR_default_text = 1; GR_width_height_text = 2; { Integer w,Integer h } GR_biggest_text = 3; GR_320_200_graphics = 4; GR_default_graphics = 5; GR_width_height_graphics = 6; { Integer w,Integer h } GR_biggest_noninterlaced_graphics = 7; GR_biggest_graphics = 8; GR_width_height_color_graphics = 9; { Integer w,Integer h,Word nc } GR_width_height_color_text = 10; { Integer w,Integer h,Word nc } GR_custom_graphics = 11; { Integer w,Integer h,Word nc,Integer vx,Integer vy } { ==== equivalent modes which do not clear the video memory ==== } GR_NC_80_25_text = 12; GR_NC_default_text = 13; GR_NC_width_height_text = 14; { Integer w,Integer h } GR_NC_biggest_text = 15; GR_NC_320_200_graphics = 16; GR_NC_default_graphics = 17; GR_NC_width_height_graphics = 18; { Integer w,Integer h } GR_NC_biggest_noninterlaced_graphics = 19; GR_NC_biggest_graphics = 20; GR_NC_width_height_color_graphics = 21; { Integer w,Integer h,Word nc } GR_NC_width_height_color_text = 22; { Integer w,Integer h,Word nc } GR_NC_custom_graphics = 23; { Integer w,Integer h,Word nc,Integer vx,Integer vy } { ==== plane instead of color based modes ==== } { colors = 1 << bpp >>> resort enum for GRX3 <<< } GR_width_height_bpp_graphics = 24; { int w,int h,int bpp } GR_width_height_bpp_text = 25; { int w,int h,int bpp } GR_custom_bpp_graphics = 26; { int w,int h,int bpp,int vx,int vy } GR_NC_width_height_bpp_graphics = 27; { int w,int h,int bpp } GR_NC_width_height_bpp_text = 28; { int w,int h,int bpp } GR_NC_custom_bpp_graphics = 29; { int w,int h,int bpp,int vx,int vy } { * Available frame modes (video memory layouts) } { ====== video frame buffer modes ====== } GR_frameUndef = 0; { undefined } GR_frameText = 1; { text modes } GR_frameHERC1 = 2; { Hercules mono } GR_frameEGAVGA1 = 3; { EGA VGA mono } GR_frameEGA4 = 4; { EGA 16 color } GR_frameSVGA4 = 5; { (Super) VGA 16 color } GR_frameSVGA8 = 6; { (Super) VGA 256 color } GR_frameVGA8X = 7; { VGA 256 color mode X } GR_frameSVGA16 = 8; { Super VGA 32768/65536 color } GR_frameSVGA24 = 9; { Super VGA 16M color } GR_frameSVGA32L = 10; { Super VGA 16M color padded #1 } GR_frameSVGA32H = 11; { Super VGA 16M color padded #2 } { ==== modes provided by the X11 driver ===== } GR_frameXWIN1 = GR_frameEGAVGA1; GR_frameXWIN4 = GR_frameSVGA4; GR_frameXWIN8 = GR_frameSVGA8; GR_frameXWIN16 = GR_frameSVGA16; GR_frameXWIN24 = GR_frameSVGA24; GR_frameXWIN32L = GR_frameSVGA32L; GR_frameXWIN32H = GR_frameSVGA32H; { ==== linear frame buffer modes ====== } GR_frameSVGA8_LFB = 12; { (Super) VGA 256 color } GR_frameSVGA16_LFB = 13; { Super VGA 32768/65536 color } GR_frameSVGA24_LFB = 14; { Super VGA 16M color } GR_frameSVGA32L_LFB = 15; { Super VGA 16M color padded #1 } GR_frameSVGA32H_LFB = 16; { Super VGA 16M color padded #2 } { ====== system RAM frame buffer modes ====== } GR_frameRAM1 = 17; { mono } GR_frameRAM4 = 18; { 16 color planar } GR_frameRAM8 = 19; { 256 color } GR_frameRAM16 = 20; { 32768/65536 color } GR_frameRAM24 = 21; { 16M color } GR_frameRAM32L = 22; { 16M color padded #1 } GR_frameRAM32H = 23; { 16M color padded #2 } GR_frameRAM3x8 = 24; { 16M color planar (image mode) } { ====== markers for scanning modes ====== } GR_firstTextFrameMode = GR_frameText; GR_lastTextFrameMode = GR_frameText; GR_firstGraphicsFrameMode = GR_frameHERC1; GR_lastGraphicsFrameMode = GR_frameSVGA32H_LFB; GR_firstRAMframeMode = GR_frameRAM1; GR_lastRAMframeMode = GR_frameRAM3x8; { * supported video adapter types } GR_UNKNOWN = -1; { not known (before driver set) } GR_VGA = 0; { VGA adapter } GR_EGA = 1; { EGA adapter } GR_HERC = 2; { Hercules mono adapter } GR_8514A = 3; { 8514A or compatible } GR_S3 = 4; { S3 graphics accelerator } GR_XWIN = 5; { X11 driver } GR_MEM = 6; { memory only driver } GR_MAX_POLYGON_POINTERS = 1000000; GR_MAX_ELLIPSE_POINTERS = 1024 + 5; GR_MAX_ANGLE_VALUE = 3600; GR_ARC_STYLE_OPEN = 0; GR_ARC_STYLE_CLOSE1 = 1; GR_ARC_STYLE_CLOSE2 = 2; { bits in the GrVideoDriver.drvflags field: } GR_DRIVERF_USER_RESOLUTION = 1; { set if driver supports user setable arbitrary resolution } Type { The video driver descriptor structure } { struct _GR_videoDriver } GrVideoDriver = record name : CString; { driver name } adapter: Char; { adapter type } inherit: ^GrVideoDriver; { inherit video modes from this } modes : ^GrVideoMode; { table of supported modes } nmodes : Integer; { number of modes } detect : Pointer; init : Pointer; reset : Pointer; selectmode: Pointer; drvflags : Integer; end; GrVideoDriverPtr = ^GrVideoDriver; { Video driver mode descriptor structure } { struct _GR_videoMode } GrVideoMode = record present : Char; { is it really available? } bpp : Char; { log2 of # of colors } width,height: ShortInt; { video mode geometry } mode : ShortInt; { BIOS mode number (if any) } lineoffset : Integer; { scan line length } privdata : Integer; { driver can use it for anything } extinfo : ^GrVideoModeExt; { extra info (maybe shared) } end; GrVideoModePtr = ^GrVideoMode; { * Video driver mode descriptor extension structure. This is a separate * structure accessed via a pointer from the main mode descriptor. The * reason for this is that frequently several modes can share the same * extended info. } { struct _GR_videoModeExt } GrVideoModeExt = record mode : Integer; { frame driver for this video mode } drv : ^GrFrameDriver; { optional frame driver override } frame : MemPtr; { frame buffer address } cprec : array[1..3] of ByteCard; { color component precisions } cpos : array[1..3] of ByteCard; { color component bit positions } flags : Integer; { mode flag bits; see "grdriver.h" } setup : Pointer; setvsize : Pointer; scroll : Pointer; setbank : Pointer; setrwbanks : Pointer; loadcolor : Pointer; LFB_Selector : Integer; end; { The frame driver descriptor structure. } { struct _GR_frameDriver } GrFrameDriver = record mode : Integer; { supported frame access mode } rmode : Integer; { matching RAM frame (if video) } is_video : Integer; { video RAM frame driver ? } row_align : Integer; { scan line size alignment } num_planes : Integer; { number of planes } bits_per_pixel : Integer; { bits per pixel } max_plane_size : Integer; { maximum plane size in bytes } init : Pointer; readpixel : Pointer; drawpixel : Pointer; drawline : Pointer; drawhline : Pointer; drawvline : Pointer; drawblock : Pointer; drawbitmap : Pointer; drawpattern : Pointer; bitblt : Pointer; bltv2r : Pointer; bltr2v : Pointer; getindexedscanline : Pointer; putscanline : Pointer; end; GrFrameDriverPtr = ^GrFrameDriver; { * driver and mode info structure } { extern const struct _GR_driverInfo } GrDriverInfoType = record vdriver : ^GrVideoDriver; { the current video driver } curmode : ^GrVideoMode; { current video mode pointer } actmode : GrVideoMode; { copy of above, resized if virtual } fdriver : GrFrameDriver; { frame driver for the current context } sdriver : GrFrameDriver; { frame driver for the screen } tdriver : GrFrameDriver; { a dummy driver for text modes } mcode : ByteCard; { code for the current mode } deftw,defth : Integer; { default text mode size } defgw,defgh : Integer; { default graphics mode size } deftc,defgc : GrColor; { default text and graphics colors } vposx,vposy : Integer; { current virtual viewport position } errsfatal : Integer; { if set, exit upon errors } moderestore : Integer; { restore startup video mode if set } splitbanks : Integer; { indicates separate R/W banks } curbank : Integer; { currently mapped bank } mdsethook : Pointer; { callback for mode set } setbank : Pointer; { banking routine } setrwbanks : Pointer; { split banking routine } end; var GrDriverInfo : ^GrDriverInfoType; AsmName 'GrDriverInfo'; external; { setup stuff } Function GrSetDriver(drvspec: CString):Integer; AsmName 'GrSetDriver'; Function GrSetMode(m, w, h, nc, vx, vy:Integer):Integer; AsmName 'GrSetMode'; Function GrSetViewport(xpos, ypos: Integer):Integer; AsmName 'GrSetViewport'; Procedure GrSetModeHook(hookfunc:Pointer); AsmName 'GrSetModeHook'; Procedure GrSetModeRestore(restoreFlag:Boolean); AsmName 'GrSetModeRestore'; Procedure GrSetErrorHandling(exitIfError:Boolean); AsmName 'GrSetErrorHandling'; Procedure GrSetEGAVGAmonoDrawnPlane(plane:Integer); AsmName 'GrSetEGAVGAmonoDrawnPlane'; Procedure GrSetEGAVGAmonoShownPlane(plane:Integer); AsmName 'GrSetEGAVGAmonoShownPlane'; Function GrGetLibraryVersion : Integer; AsmName 'GrGetLibraryVersion'; Function GrGetLibrarySystem : Integer; AsmName 'GrGetLibrarySystem'; { inquiry stuff ---- many of these can be macros } Function GrCurrentMode:Integer; AsmName 'GrCurrentMode'; Function GrAdapterType:Integer; AsmName 'GrAdapterType'; Function GrCurrentFrameMode:Integer; AsmName 'GrCurrentFrameMode'; Function GrScreenFrameMode:Integer; AsmName 'GrScreenFrameMode'; Function GrCoreFrameMode:Integer; AsmName 'GrCoreFrameMode'; Function GrCurrentVideoDriver: GrVideoDriverPtr; AsmName 'GrCurrentVideoDriver' ; Function GrCurrentVideoMode:GrVideoModePtr; AsmName 'GrCurrentVideoMode'; Function GrVirtualVideoMode:GrVideoModePtr; AsmName 'GrVirtualVideoMode'; Function GrCurrentFrameDriver: GrFrameDriverPtr; AsmName 'GrCurrentFrameDriver'; Function GrScreenFrameDriver: GrFrameDriverPtr; AsmName 'GrScreenFrameDriver'; Function GrFirstVideoMode(fmode:Integer):GrVideoModePtr; AsmName 'GrFirstVideoMode'; Function GrNextVideoMode(prev:GrVideoModePtr):GrVideoModePtr; AsmName 'GrNextVideoMode'; Function GrScreenX:Integer; AsmName 'GrScreenX'; Function GrScreenY:Integer; AsmName 'GrScreenY'; Function GrVirtualX:Integer; AsmName 'GrVirtualX'; Function GrVirtualY:Integer; AsmName 'GrVirtualY'; Function GrViewportX:Integer; AsmName 'GrViewportX'; Function GrViewportY:Integer; AsmName 'GrViewportY'; Function GrScreenIsVirtual:Boolean; AsmName 'GrScreenIsVirtual'; { RAM context geometry and memory allocation inquiry stuff } Function GrFrameNumPlanes(md:Integer):Integer; AsmName 'GrFrameNumPlanes'; Function GrFrameLineOffset(md,width:Integer):Integer; AsmName 'GrFrameLineOffset'; Function GrFramePlaneSize(md,w,h:Integer):Integer; AsmName 'GrFramePlaneSize'; Function GrFrameContextSize(md,w,h:Integer):Integer; AsmName 'GrFrameContextSize'; Function GrNumPlanes:Integer; AsmName 'GrNumPlanes'; Function GrLineOffset(width:Integer):Integer; AsmName 'GrLineOffset'; Function GrPlaneSize(w,h:Integer):Integer; AsmName 'GrPlaneSize'; Function GrContextSize(w,h:Integer):Integer; AsmName 'GrContextSize'; { ================================================================== FRAME BUFFER, CONTEXT AND CLIPPING STUFF ================================================================== } Type GrFrameType = record gf_baseaddr : array[0..3] of MemPtr; { base address of frame memory } gf_selector : ShortInt; { frame memory segment selector } gf_onscreen : Char; { is it in video memory ? } gf_memflags : Char; { memory allocation flags } gf_lineoffset : Integer; { offset to next scan line in bytes } gf_driver : ^GrFrameDriver; { frame access functions } end; { struct _GR_context } GrContext = record gc_frame : GrFrameType; { frame buffer info } gc_root : ^GrContext; { context which owns frame } gc_xmax : Integer; { max X coord (width - 1) } gc_ymax : Integer; { max Y coord (height - 1) } gc_xoffset : Integer; { X offset from root's base } gc_yoffset : Integer; { Y offset from root's base } gc_xcliplo : Integer; { low X clipping limit } gc_ycliplo : Integer; { low Y clipping limit } gc_xcliphi : Integer; { high X clipping limit } gc_ycliphi : Integer; { high Y clipping limit } gc_usrxbase : Integer; { user window min X coordinate } gc_usrybase : Integer; { user window min Y coordinate } gc_usrwidth : Integer; { user window width } gc_usrheight : Integer; { user window height } end; GrContextPtr = ^GrContext; { extern const struct _GR_contextInfo } GrContextInfoType = record current: GrContext; { the current context } screen : GrContext; { the screen context } end; var GrContextInfo : GrContextInfoType; AsmName 'GrContextInfo'; external; Function GrCreateContext(w, h: Integer; memory: MemPtr; where : GrContextPtr): GrContextPtr; AsmName 'GrCreateContext'; Function GrCreateFrameContext(md: ByteCard; w, h: Integer; memory: MemPtr; where : GrContextPtr): GrContextPtr; AsmName 'GrCreateFrameContext'; Function GrCreateSubContext(x1, y1, x2, y2: Integer; parent, where : GrContextPtr): GrContextPtr; AsmName 'GrCreateSubContext'; Function GrSaveContext(where : GrContextPtr): GrContextPtr; AsmName 'GrSaveContext'; Function GrCurrentContext: GrContextPtr; AsmName 'GrCurrentContext'; Function GrScreenContext : GrContextPtr; AsmName 'GrScreenContext'; Procedure GrDestroyContext(context: GrContextPtr); AsmName 'GrDestroyContext'; Procedure GrResizeSubContext(context: GrContextPtr; x1, y1, x2, y2: Integer); AsmName 'GrResizeSubContext'; Procedure GrSetContext(context: GrContextPtr); AsmName 'GrSetContext'; Procedure GrSetClipBox(x1, y1, x2, y2:Integer); AsmName 'GrSetClipBox'; Procedure GrGetClipBox(var x1p, y1p, x2p, y2p: Integer); AsmName 'GrGetClipBox'; Procedure GrResetClipBox; AsmName 'GrResetClipBox'; Function GrMaxX: Integer; AsmName 'GrMaxX'; Function GrMaxY: Integer; AsmName 'GrMaxY'; Function GrSizeX:Integer; AsmName 'GrSizeX'; Function GrSizeY:Integer; AsmName 'GrSizeY'; Function GrLowX: Integer; AsmName 'GrLowX'; Function GrLowY: Integer; AsmName 'GrLowY'; Function GrHighX:Integer; AsmName 'GrHighX'; Function GrHighY:Integer; AsmName 'GrHighY'; { ================================================================== COLOR STUFF ================================================================== } { Flags to 'OR' to colors for various operations } const GrWRITE = 0 ; { write color } GrXOR = $01000000 ; { to "XOR" any color to the screen } GrOR = $02000000 ; { to "OR" to the screen } GrAND = $03000000 ; { to "AND" to the screen } GrIMAGE = $04000000 ; { BLIT: write, except given color } GrCVALUEMASK = $00ffffff ; { color value mask } GrCMODEMASK = $ff000000 ; { color operation mask } GrNOCOLOR = GrXOR or 0 ; { GrNOCOLOR is used for "no" color } Function GrColorValue(c:GrColor):GrColor; AsmName 'GrColorValue'; Function GrColorMode(c:GrColor):GrColor; AsmName 'GrColorMode'; Function GrWriteModeColor(c:GrColor):GrColor; AsmName 'GrWriteModeColor'; Function GrXorModeColor(c:GrColor):GrColor; AsmName 'GrXorModeColor'; Function GrOrModeColor(c:GrColor):GrColor; AsmName 'GrOrModeColor'; Function GrAndModeColor(c:GrColor):GrColor; AsmName 'GrAndModeColor'; Function GrImageModeColor(c:GrColor):GrColor; AsmName 'GrImageModeColor'; Procedure GrResetColors; AsmName 'GrResetColors'; Procedure GrSetRGBcolorMode; AsmName 'GrSetRGBcolorMode'; Procedure GrRefreshColors; AsmName 'GrRefreshColors'; Function GrNumColors:GrColor; AsmName 'GrNumColors'; Function GrNumFreeColors:GrColor; AsmName 'GrNumFreeColors'; Function GrBlack:GrColor; AsmName 'GrBlack'; Function GrWhite:GrColor; AsmName 'GrWhite'; Function GrBuildRGBcolorT(r,g,b:Integer):GrColor; AsmName 'GrBuildRGBcolorT'; Function GrBuildRGBcolorR(r,g,b:Integer):GrColor; AsmName 'GrBuildRGBcolorR'; Function GrRGBcolorRed(c:GrColor):Integer ; AsmName 'GrRGBcolorRed'; Function GrRGBcolorGreen(c:GrColor):Integer ; AsmName 'GrRGBcolorGreen'; Function GrRGBcolorBlue(c:GrColor):Integer ; AsmName 'GrRGBcolorBlue'; Function GrAllocColor(r,g,b:Integer):GrColor; AsmName 'GrAllocColor'; { shared, read-only } Function GrAllocColorID(r,g,b:Integer):GrColor; AsmName 'GrAllocColorID'; { potentially inlined version } Function GrAllocCell:GrColor; AsmName 'GrAllocCell'; { unshared, read-write } Function GrAllocEgaColors:GrColorsPtr; AsmName 'GrAllocEgaColors'; { shared, read-only standard EGA colors } Procedure GrSetColor(c:GrColor; r,g,b:Integer); AsmName 'GrSetColor'; Procedure GrFreeColor(c:GrColor); AsmName 'GrFreeColor'; Procedure GrFreeCell(c:GrColor); AsmName 'GrFreeCell'; Procedure GrQueryColor(c:GrColor; var r,g,b:Integer); AsmName 'GrQueryColor'; Procedure GrQueryColorID(c:GrColor; var r,g,b:Integer); AsmName 'GrQueryColorID'; Function GrColorSaveBufferSize:Integer ; AsmName 'GrColorSaveBufferSize'; Procedure GrSaveColors(buffer:Pointer); AsmName 'GrSaveColors'; Procedure GrRestoreColors(buffer:Pointer); AsmName 'GrRestoreColors'; Type { typedef struct } { framed box colors } GrFBoxColors = record fbx_Integercolor : Integer; fbx_topcolor : Integer; fbx_rightcolor : Integer; fbx_bottomcolor : Integer; fbx_leftcolor : Integer; end; Procedure GrClearScreen(bg:GrColor); AsmName 'GrClearScreen'; Procedure GrClearClipBox(bg:GrColor); AsmName 'GrClearClipBox'; Procedure GrPlot(x, y: Integer; c:GrColor); AsmName 'GrPlot'; Procedure GrLine(x1, y1, x2, y2: Integer; c:GrColor); AsmName 'GrLine'; Procedure GrHLine(x1, x2, y:Integer; c:GrColor); AsmName 'GrHLine'; Procedure GrVLine(x, y1, y2: Integer; c: GrColor); AsmName 'GrVLine'; Procedure GrBox(x1, y1, x2, y2: Integer; c: GrColor); AsmName 'GrBox'; Procedure GrFilledBox(x1, y1, x2, y2: Integer; c: GrColor); AsmName 'GrFilledBox'; Procedure GrFramedBox(x1, y1, x2, y2, wdt: Integer; protected var c: GrFBoxColors); AsmName 'GrFramedBox'; Function GrGenerateEllipse(xc, yc, xa, ya:Integer; var Points{ : array of PointType }):Integer; AsmName 'GrGenerateEllipse'; Function GrGenerateEllipseArc(xc, yc, xa, ya, start, ende: Integer; var Points{ : array of PointType }):Integer; AsmName 'GrGenerateEllipseArc'; Procedure GrLastArcCoords(var xs, ys, xe, ye, xc, yc: Integer); AsmName 'GrLastArcCoords'; Procedure GrCircle(xc, yc, r: Integer; c: GrColor); AsmName 'GrCircle'; Procedure GrEllipse(xc, yc, xa, ya: Integer; c: GrColor); AsmName 'GrEllipse'; Procedure GrCircleArc(xc, yc, r, start, ende, style: Integer; c: GrColor); AsmName 'GrCircleArc'; Procedure GrEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; c: GrColor); AsmName 'GrEllipseArc'; Procedure GrFilledCircle(xc, yc, r: Integer; c: GrColor); AsmName 'GrFilledCircle'; Procedure GrFilledEllipse(xc, yc, xa, ya: Integer; c: GrColor); AsmName 'GrFilledEllipse'; Procedure GrFilledCircleArc(xc, yc, r, start, ende, style: Integer; c: GrColor); AsmName 'GrFilledCircleArc'; Procedure GrFilledEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; c: GrColor); AsmName 'GrFilledEllipseArc'; Procedure GrPolyLine(numpts: Integer; var Points{ : array of PointType }; c: GrColor); AsmName 'GrPolyLine'; Procedure GrPolygon(numpts: Integer; var Points{ : array of PointType }; c: GrColor); AsmName 'GrPolygon'; Procedure GrFilledConvexPolygon(numpts: Integer; var Points{ : array of PointType }; c: GrColor); AsmName 'GrFilledConvexPolygon'; Procedure GrFilledPolygon(numpts: Integer; var Points{ : array of PointType }; c: GrColor); AsmName 'GrFilledPolygon'; Procedure GrBitBlt(dst: GrContextPtr; x, y: Integer; src: GrContextPtr; x1, y1, x2, y2: Integer; op: GrColor); AsmName 'GrBitBlt'; Function GrPixel(x, y:Integer):GrColor; AsmName 'GrPixel'; Function GrPixelC(c: GrContextPtr; x, y: Integer): GrColor; AsmName 'GrPixelC'; Procedure GrFloodFill(x, y: Integer; border, c: GrColor); AsmName 'GrFloodFill'; Function GrGetScanline(x1,x2,yy: Integer) : GrColorsPtr; AsmName 'GrGetScanline'; Function GrGetScanlineC(ctx: GrContextPtr; x1,x2,yy: Integer) : GrColorsPtr; AsmName 'GrGetScanlineC'; (* Input ctx: source context, if NULL the current context is used *) (* x1 : first x coordinate read *) (* x2 : last x coordinate read *) (* yy : y coordinate *) (* Output NIL : error / no data (clipping occured) *) (* else *) (* p[0..w]: pixel values read *) (* (w = |x2-y1|) *) (* Output data is valid until next GRX call ! *) Procedure GrPutScanline(x1,x2,yy: Integer;c: GrColorsPtr; op: GrColor); AsmName 'GrPutScanline'; (* Input x1 : first x coordinate to be set *) (* x2 : last x coordinate to be set *) (* yy : y coordinate *) (* c : c[0..(|x2-x1|] hold the pixel data *) (* op : Operation (GrWRITE/GrXOR/GrOR/GrAND/GrIMAGE) *) (* *) (* Note c[..] data must fit GrCVALUEMASK otherwise the results *) (* are implementation dependend. *) (* => You can't supply operation code with the pixel data! *) { ================================================================== NON CLIPPING DRAWING PRIMITIVES ================================================================== } Procedure GrPlotNC(x, y: Integer; c: GrColor); AsmName 'GrPlotNC'; Procedure GrLineNC(x1, y1, x2, y2: Integer; c: GrColor); AsmName 'GrLineNC'; Procedure GrHLineNC(x1, x2, y: Integer; c: GrColor); AsmName 'GrHLineNC'; Procedure GrVLineNC(x, y1, y2: Integer; c: GrColor); AsmName 'GrVLineNC'; Procedure GrBoxNC(x1, y1, x2, y2: Integer; c: GrColor); AsmName 'GrBoxNC'; Procedure GrFilledBoxNC(x1, y1, x2, y2: Integer; c: GrColor); AsmName 'GrFilledBoxNC'; Procedure GrFramedBoxNC(x1, y1, x2, y2, wdt: Integer; protected var c: GrFBoxColors); AsmName 'GrFramedBoxNC'; Procedure GrBitBltNC(dst: GrContextPtr; x, y: Integer; src: GrContextPtr; x1, y1, x2, y2: Integer; op: GrColor); AsmName 'GrBitBltNC'; Function GrPixelNC(x, y:Integer):GrColor; AsmName 'GrPixelNC'; Function GrPixelCNC(c: GrContextPtr; x, y: Integer): GrColor; AsmName 'GrPixelCNC'; { ================================================================== FONTS AND TEXT PRIMITIVES ================================================================== } { text drawing directions } Const GR_TEXT_RIGHT = 0; { normal } GR_TEXT_DOWN = 1; { downward } GR_TEXT_LEFT = 2; { upside down, right to left } GR_TEXT_UP = 3; { upward } GR_TEXT_DEFAULT = GR_TEXT_RIGHT; { GR_TEXT_IS_VERTICAL(d) = ((d) and 1); } { text alignment options } GR_ALIGN_LEFT = 0; { X only } GR_ALIGN_TOP = 0; { Y only } GR_ALIGN_CENTER = 1; { X, Y } GR_ALIGN_RIGHT = 2; { X only } GR_ALIGN_BOTTOM = 2; { Y only } GR_ALIGN_BASELINE = 3; { Y only } GR_ALIGN_DEFAULT = GR_ALIGN_LEFT; { character types in text strings } GR_BYTE_TEXT = 0; { one byte per character } GR_WORD_TEXT = 1; { two bytes per character } GR_ATTR_TEXT = 2; { chr w/ PC style attribute byte } { OR this to the foreground color value for underlined text when using GR_BYTE_TEXT or GR_WORD_TEXT modes. } { GR_UNDERLINE_TEXT = (GrXOR << 4); } { Font conversion flags for 'GrLoadConvertedFont'. OR them as desired. } GR_FONTCVT_NONE = 0; { no conversion } GR_FONTCVT_SKIPCHARS = 1; { load only selected characters } GR_FONTCVT_RESIZE = 2; { resize the font } GR_FONTCVT_ITALICIZE = 4; { tilt font for "italic" look } GR_FONTCVT_BOLDIFY = 8; { make a "bold"(er) font } GR_FONTCVT_FIXIFY = 16; { convert prop. font to fixed wdt } GR_FONTCVT_PROPORTION = 32; { convert fixed font to prop. wdt } Type { font structures } { typedef struct _GR_fontHeader } { font descriptor } GrFontHeader = record name : CString; { font name } family : CString; { font family name } proportional : Char; { characters have varying width } scalable : Char; { derived from a scalable font } preloaded : Char; { set when linked Integero program } modified : Char; { "tweaked" font (resized, etc..) } width : Integer; { width (proportional=>average) } height : Integer; { font height } baseline : Integer; { baseline pixel pos (from top) } ulpos : Integer; { underline pixel pos (from top) } ulheight : Integer; { underline width } minchar : Integer; { lowest character code in font } numchars : Integer; { number of characters in font } end; { typedef struct _GR_fontChrInfo } { character descriptor } GrFontChrInfo = record width : Integer; { width of this character } offset : Integer; { offset from start of bitmap } end; { typedef struct _GR_font } { the complete font } AuxoffsType = array[1..7] of Integer; GrFont = record h : GrFontHeader; { the font info structure } bitmap : MemPtr; { character bitmap array } auxmap : MemPtr; { map for rotated & underline chrs } minwidth : Integer; { width of narrowest character } maxwidth : Integer; { width of widest character } auxsize : Integer; { allocated size of auxiliary map } auxnext : Integer; { next free byte in auxiliary map } auxoffs : ^AuxoffsType; { offsets to completed aux chars } chrinfo : array[1..1] of GrFontChrInfo; { character info (not act. size) } end; GrFontPtr = ^GrFont; var GrFont_PC6x8 : GrFont; AsmName 'GrFont_PC6x8'; external; GrFont_PC8x8 : GrFont; AsmName 'GrFont_PC8x8'; external; GrFont_PC8x14 : GrFont; AsmName 'GrFont_PC8x14'; external; GrFont_PC8x16 : GrFont; AsmName 'GrFont_PC8x16'; external; GrDefaultFont : GrFont; AsmName 'GrFont_PC8x14'; external; Function GrLoadFont(name: CString): GrFontPtr; AsmName 'GrLoadFont'; Function GrLoadConvertedFont(name: CString; cvt, w, h, minch, maxch: Integer): GrFontPtr; AsmName 'GrLoadConvertedFont'; Function GrBuildConvertedFont(protected var from: GrFont; cvt, w, h, minch, maxch: Integer): GrFontPtr; AsmName 'GrBuildConvertedFont'; Procedure GrUnloadFont(var font: GrFont); AsmName 'GrUnloadFont'; Procedure GrDumpFont(protected var f: GrFont; CsymbolName, FileName: CString); AsmName 'GrDumpFont'; Procedure GrSetFontPath(path_list: CString); AsmName 'GrSetFontPath'; Function GrFontCharPresent(protected var font: GrFont; chr: Integer): Boolean; AsmName 'GrFontCharPresent'; Function GrFontCharWidth(protected var font: GrFont; chr: Integer): Integer; AsmName 'GrFontCharWidth'; Function GrFontCharHeight(protected var font: GrFont; chr: Integer): Integer; AsmName 'GrFontCharHeight'; Function GrFontCharBmpRowSize(protected var font: GrFont; chr: Integer): Integer; AsmName 'GrFontCharBmpRowSize'; Function GrFontCharBitmapSize(protected var font: GrFont; chr: Integer): Integer; AsmName 'GrFontCharBitmapSize'; Function GrFontStringWidth(protected var font: GrFont; text: CString; len, typ_e: Integer): Integer; AsmName 'GrFontStringWidth'; Function GrFontStringHeight(protected var font: GrFont; text: CString; len, typ_e: Integer): Integer; AsmName 'GrFontStringHeight'; Function GrProportionalTextWidth(protected var font: GrFont; text: CString; len, typ_e: Integer): Integer; AsmName 'GrProportionalTextWidth'; Function GrBuildAuxiliaryBitmap(var font: GrFont; chr, dir, ul: Integer): MemPtr; AsmName 'GrBuildAuxiliaryBitmap'; Function GrFontCharBitmap(protected var font: GrFont; chr: Integer): MemPtr; AsmName 'GrFontCharBitmap'; Function GrFontCharAuxBmp(var font: GrFont; chr, dir, ul: Integer): MemPtr; AsmName 'GrFontCharAuxBmp'; Type GrColorTableP = ^GrColor; { typedef union _GR_textColor } { text color union } GrTextColor = record case 1..2 of 1: (v : GrColor); { color value for "direct" text } 2: (p : GrColorTableP); { color table for attribute text } end; { typedef struct _GR_textOption } { text drawing option structure } GrTextOption = record txo_font : GrFontPtr; { font to be used } txo_fgcolor : GrTextColor; { foreground color } txo_bgcolor : GrTextColor; { background color } txo_chrtype : ByteCard; { character type (see above) } txo_direct : ByteCard; { direction (see above) } txo_xalign : ByteCard; { X alignment (see above) } txo_yalign : ByteCard; { Y alignment (see above) } end; { typedef struct } { fixed font text window desc. } GrTextRegion = record txr_font : GrTextColor; { font to be used } txr_fgcolor : GrTextColor; { foreground color } txr_bgcolor : GrTextColor; { background color } txr_buffer : Pointer; { pointer to text buffer } txr_backup : Pointer; { optional backup buffer } txr_width : Integer; { width of area in chars } txr_height : Integer; { height of area in chars } txr_lineoffset : Integer; { offset in buffer(s) between rows } txr_xpos : Integer; { upper left corner X coordinate } txr_ypos : Integer; { upper left corner Y coordinate } txr_chrtype : Char; { character type (see above) } end; Function GrCharWidth(chr: Integer; protected var opt: GrTextOption): Integer; AsmName 'GrCharWidth'; Function GrCharHeight(chr: Integer; protected var opt: GrTextOption): Integer; AsmName 'GrCharHeight'; Procedure GrCharSize(chr: Integer; protected var opt: GrTextOption; var w, h: Integer); AsmName 'GrCharSize'; Function GrStringWidth(text: CString; length: Integer; protected var opt: GrTextOption): Integer; AsmName 'GrStringWidth'; Function GrStringHeight(text: CString; length: Integer; protected var opt: GrTextOption): Integer; AsmName 'GrStringHeight'; Procedure GrStringSize(text: CString; length: Integer; protected var opt: GrTextOption;var w, h: Integer); AsmName 'GrStringSize'; Procedure GrDrawChar(chr, x, y: Integer; protected var opt: GrTextOption); AsmName 'GrDrawChar'; Procedure GrDrawString(text: CString; length, x, y: Integer; protected var opt: GrTextOption); AsmName 'GrDrawString'; Procedure GrTextXY(x, y: Integer; text: CString; fg, bg: GrColor); AsmName 'GrTextXY'; Procedure GrDumpChar(chr, col, row: Integer; protected var r: GrTextRegion); AsmName 'GrDumpChar'; Procedure GrDumpText(col, row, wdt, hgt: Integer; protected var r: GrTextRegion); AsmName 'GrDumpText'; Procedure GrDumpTextRegion(protected var r: GrTextRegion); AsmName 'GrDumpTextRegion'; { ================================================================= THICK AND DASHED LINE DRAWING PRIMITIVES ================================================================== } { * custom line option structure * zero or one dash pattern length means the line is continuous * the dash pattern always begins with a drawn section } Type GrLineOption = record no_color : GrColor; { color used to draw line } lno_width : Integer; { width of the line } lno_pattlen : Integer; { length of the dash pattern } lno_dashpat : ^ByteCard; { draw/nodraw pattern } end; Procedure GrCustomLine(x1, y1, x2, y2: Integer; protected var o: GrLineOption); AsmName 'GrCustomLine'; Procedure GrCustomBox(x1, y1, x2, y2: Integer; protected var o: GrLineOption); AsmName 'GrCustomBox'; Procedure GrCustomCircle(xc, yc, r: Integer; protected var o: GrLineOption); AsmName 'GrCustomCircle'; Procedure GrCustomEllipse(xc, yc, r: Integer; protected var o: GrLineOption); AsmName 'GrCustomEllipse'; Procedure GrCustomCircleArc(xc, yc, r, start, ende, style: Integer; protected var o: GrLineOption); AsmName 'GrCustomCircleArc'; Procedure GrCustomEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; protected var o: GrLineOption); AsmName 'GrCustomEllipseArc'; Procedure GrCustomPolyLine(numpts: Integer; var Points{ : array of PointType }; protected var o: GrLineOption); AsmName 'GrCustomPolyLine'; Procedure GrCustomPolygon(numpts: Integer; var Points{ : array of PointType }; protected var o: GrLineOption); AsmName 'GrCustomPolygon'; { ================================================================== PATTERNED DRAWING AND FILLING PRIMITIVES ================================================================== } { * BITMAP: a mode independent way to specify a fill pattern of two * colors. It is always 8 pixels wide (1 byte per scan line), its * height is user-defined. SET THE TYPE FLAG TO ZERO!!! } Type { typedef struct _GR_bitmap } GrBitmap = record bmp_ispixmap : Integer; { type flag for pattern union } bmp_height : Integer; { bitmap height } bmp_data : ^ByteCard; { pointer to the bit pattern } bmp_fgcolor : GrColor; { foreground color for fill } bmp_bgcolor : GrColor; { background color for fill } bmp_memflags : Integer; { set if dynamically allocated } end; { * PIXMAP: a fill pattern stored in a layout identical to the video RAM * for filling using 'bitblt'-s. It is mode dependent, typically one * of the library functions is used to build it. KEEP THE TYPE FLAG * NONZERO!!! } { typedef struct _GR_pixmap } GrPixmap = record pxp_ispixmap : Integer; { type flag for pattern union } pxp_width : Integer; { pixmap width (in pixels) } pxp_height : Integer; { pixmap height (in pixels) } pxp_oper : GrColor; { bitblt mode (SET, OR, XOR, AND, IMAGE) } pxp_source : GrFrameType; { source context for fill } end; { * Fill pattern union -- can either be a bitmap or a pixmap } { typedef union _GR_pattern } GrPattern = record gp_ispixmap : Integer; { nonzero for pixmaps } gp_bitmap : GrBitmap; { fill bitmap } gp_pixmap : GrPixmap; { fill pixmap } end; GrPatternPtr = ^GrPattern; { * Draw pattern for line drawings -- specifies both the: * (1) fill pattern, and the * (2) custom line drawing option } GrLinePattern = record lnp_pattern : GrPatternPtr; { fill pattern } lnp_option : ^GrLineOption; { width + dash pattern } end; GrLinePatternPtr = GrLinePattern; Function GrBuildPixmap(protected var Pixels; w, h: Integer; protected var Colors { : array of GrColor }): GrPatternPtr; AsmName 'GrBuildPixmap'; Function GrBuildPixmapFromBits(protected var Bits; w, h: Integer; fgc, bgc: GrColor): GrPatternPtr; AsmName 'GrBuildPixmapFromBits'; Function GrConvertToPixmap(src: GrContextPtr): GrPatternPtr; AsmName 'GrConvertToPixmap'; Procedure GrDestroyPattern(p: GrPatternPtr); AsmName 'GrDestroyPattern'; Procedure GrPatternedLine(x1, y1, x2, y2: Integer; lp: GrLinePatternPtr); AsmName 'GrPatternedLine'; Procedure GrPatternedBox(x1, y1, x2, y2: Integer; lp: GrLinePatternPtr); AsmName 'GrPatternedBox'; Procedure GrPatternedCircle(xc, yc, r: Integer; lp: GrLinePatternPtr); AsmName 'GrPatternedCircle'; Procedure GrPatternedEllipse(xc, yc, xa, ya: Integer; lp: GrLinePatternPtr); AsmName 'GrPatternedEllipse'; Procedure GrPatternedCircleArc(xc, yc, r, start, ende, style: Integer; lp: GrLinePatternPtr); AsmName 'GrPatternedCircleArc'; Procedure GrPatternedEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; lp: GrLinePatternPtr); AsmName 'GrPatternedEllipseArc'; Procedure GrPatternedPolyLine(numpts: Integer; var Points{ : array of PointType }; lp: GrLinePatternPtr); AsmName 'GrPatternedPolyLine'; Procedure GrPatternedPolygon(numpts: Integer; var Points{ : array of PointType }; lp: GrLinePatternPtr); AsmName 'GrPatternedPolygon'; Procedure GrPatternFilledPlot(x, y: Integer; p: GrPatternPtr); AsmName 'GrPatternFilledPlot'; Procedure GrPatternFilledLine(x1, y1, x2, y2: Integer; p: GrPatternPtr); AsmName 'GrPatternFilledLine'; Procedure GrPatternFilledBox(x1, y1, x2, y2: Integer; p: GrPatternPtr); AsmName 'GrPatternFilledBox'; Procedure GrPatternFilledCircle(xc, yc, r: Integer; p: GrPatternPtr); AsmName 'GrPatternFilledCircle'; Procedure GrPatternFilledEllipse(xc, yc, xa, ya: Integer; p: GrPatternPtr); AsmName 'GrPatternFilledEllipse'; Procedure GrPatternFilledCircleArc(xc, yc, r, start, ende, style: Integer; p: GrPatternPtr); AsmName 'GrPatternFilledCircleArc'; Procedure GrPatternFilledEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; p: GrPatternPtr); AsmName 'GrPatternFilledEllipseArc'; Procedure GrPatternFilledConvexPolygon(numpts: Integer; var Points{ : array of PointType }; p: GrPatternPtr); AsmName 'GrPatternFilledConvexPolygon'; Procedure GrPatternFilledPolygon(numpts: Integer; var Points{ : array of PointType }; p: GrPatternPtr); AsmName 'GrPatternFilledPolygon'; Procedure GrPatternFloodFill(x, y: Integer; border: GrColor; p: GrPatternPtr); AsmName 'GrPatternFloodFill'; Procedure GrPatternDrawChar(chr, x, y: Integer; protected var opt: GrTextOption; p: GrPatternPtr); AsmName 'GrPatternDrawChar'; Procedure GrPatternDrawString(text: CString; length, x, y: Integer; protected var opt: GrTextOption; p: GrPatternPtr); AsmName 'GrPatternDrawString'; Procedure GrPatternDrawStringExt(text: CString; length, x, y: Integer; protected var opt: GrTextOption; p: GrPatternPtr); AsmName 'GrPatternDrawStringExt'; (* ** - Image Utility ** by Michal Stencl Copyright (c) 1998 for GRX ** ** ** - [stenclpmd@ba.telecom.sk] ** *) Type { Original GRX decl: GrImage = GrPixmap; GrImagePtr = ^GrImage; GPC isn't case sensitive so GrImage conficts with GrIMAGE above. Since we only need GrImagePtr we take a short cut here: } GrImagePtr = ^GrPixmap; (* Flags for GrImageInverse() *) const GR_IMAGE_INVERSE_LR = 1; (* inverse left right *) GR_IMAGE_INVERSE_TD = 2; (* inverse top down *) Function GrImageBuild(protected var Pixels; w, h: Integer; protected var Colors { : array of GrColor }) : GrImagePtr; AsmName 'GrImageBuild'; Procedure GrImageDestroy(i: GrImagePtr); AsmName 'GrImageDestroy'; Procedure GrImageDisplay(x,y: Integer; i: GrImagePtr); AsmName 'GrImageDisplay'; Procedure GrImageDisplayExt(x1,y1,x2,y2: Integer; i: GrImagePtr); AsmName 'GrImageDisplayExt'; Procedure GrImageFilledBoxAlign(xo,yo,x1,y1,x2,y2: Integer; p: GrImagePtr); AsmName 'GrImageFilledBoxAlign'; Procedure GrImageHLineAlign(xo,yo,x,y,width: Integer; p: GrImagePtr); AsmName 'GrImageHLineAlign'; Procedure GrImagePlotAlign(xo,yo,x,y: Integer; p: GrImagePtr); AsmName 'GrImagePlotAlign'; Function GrImageInverse(p: GrImagePtr; flag: Integer) : GrImagePtr; AsmName 'GrImageInverse'; Function GrImageStretch(p: GrImagePtr; nwidth, nheight: Integer) : GrImagePtr; AsmName 'GrImageStretch'; Function GrImageFromPattern(p: GrPatternPtr) : GrImagePtr; AsmName 'GrImageFromPattern'; Function GrImageFromContext(c: GrContextPtr) : GrImagePtr; AsmName 'GrImageFromContext'; Function GrImageBuildUsedAsPattern(protected var Pixels; w, h: Integer; protected var Colors { : array of GrColor }) : GrImagePtr; AsmName 'GrImageBuildUsedAsPattern'; Function GrPatternFromImage(i: GrImagePtr) : GrPatternPtr; AsmName 'GrPatternFromImage'; { ================================================================== DRAWING IN USER WINDOW COORDINATES ================================================================== } Procedure GrSetUserWindow( x1, y1, x2, y2: Integer); Procedure GrGetUserWindow(var x1, y1, x2, y2: Integer); Procedure GrGetScreenCoord(var x, y: Integer); Procedure GrGetUserCoord(var x, y: Integer); Procedure GrUsrPlot(x, y: Integer; c:GrColor); AsmName 'GrUsrPlot'; Procedure GrUsrLine(x1, y1, x2, y2: Integer; c:GrColor); AsmName 'GrUsrLine'; Procedure GrUsrHLine(x1, x2, y:Integer; c:GrColor); AsmName 'GrUsrHLine'; Procedure GrUsrVLine(x, y1, y2: Integer; c: GrColor); AsmName 'GrUsrVLine'; Procedure GrUsrBox(x1, y1, x2, y2: Integer; c: GrColor); AsmName 'GrUsrBox'; Procedure GrUsrFilledBox(x1, y1, x2, y2: Integer; c: GrColor); AsmName 'GrUsrFilledBox'; Procedure GrUsrFramedBox(x1, y1, x2, y2, wdt: Integer; c: GrFBoxColors); AsmName 'GrUsrFramedBox'; Procedure GrUsrCircle(xc, yc, r: Integer; c: GrColor); AsmName 'GrUsrCircle'; Procedure GrUsrEllipse(xc, yc, xa, ya: Integer; c: GrColor); AsmName 'GrUsrEllipse'; Procedure GrUsrCircleArc(xc, yc, r, start, ende, style: Integer; c: GrColor); AsmName 'GrUsrCircleArc'; Procedure GrUsrEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; c: GrColor); AsmName 'GrUsrEllipseArc'; Procedure GrUsrFilledCircle(xc, yc, r: Integer; c: GrColor); AsmName 'GrUsrFilledCircle'; Procedure GrUsrFilledEllipse(xc, yc, xa, ya: Integer; c: GrColor); AsmName 'GrUsrFilledEllipse'; Procedure GrUsrFilledCircleArc(xc, yc, r, start, ende, style: Integer; c: GrColor); AsmName 'GrUsrFilledCircleArc'; Procedure GrUsrFilledEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; c: GrColor); AsmName 'GrUsrFilledEllipseArc'; Procedure GrUsrPolyLine(numpts: Integer; var Points{ : array of PointType }; c: GrColor); AsmName 'GrUsrPolyLine'; Procedure GrUsrPolygon(numpts: Integer; var Points{ : array of PointType }; c: GrColor); AsmName 'GrUsrPolygon'; Procedure GrUsrFilledConvexPolygon(numpts: Integer; var Points{ : array of PointType }; c: GrColor); AsmName 'GrUsrFilledConvexPolygon'; Procedure GrUsrFilledPolygon(numpts: Integer; var Points{ : array of PointType }; c: GrColor); AsmName 'GrUsrFilledPolygon'; Procedure GrUsrFloodFill(x, y: Integer; border, c: GrColor); AsmName 'GrUsrFloodFill'; Function GrUsrPixel(x, y:Integer):GrColor; AsmName 'GrUsrPixel'; Function GrUsrPixelC(c: GrContextPtr; x, y: Integer):GrColor; AsmName 'GrUsrPixelC'; Procedure GrUsrCustomLine(x1, y1, x2, y2: Integer; protected var o: GrLineOption); AsmName 'GrUsrCustomLine'; Procedure GrUsrCustomBox(x1, y1, x2, y2: Integer; protected var o: GrLineOption); AsmName 'GrUsrCustomBox'; Procedure GrUsrCustomCircle(xc, yc, r: Integer; protected var o: GrLineOption); AsmName 'GrUsrCustomCircle'; Procedure GrUsrCustomEllipse(xc, yc, r: Integer; protected var o: GrLineOption); AsmName 'GrUsrCustomEllipse'; Procedure GrUsrCustomCircleArc(xc, yc, r, start, ende, style: Integer; protected var o: GrLineOption); AsmName 'GrUsrCustomCircleArc'; Procedure GrUsrCustomEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; protected var o: GrLineOption); AsmName 'GrUsrCustomEllipseArc'; Procedure GrUsrCustomPolyLine(numpts: Integer; var Points{ : array of PointType }; protected var o: GrLineOption); AsmName 'GrUsrCustomPolyLine'; Procedure GrUsrCustomPolygon(numpts: Integer; var Points{ : array of PointType }; protected var o: GrLineOption); AsmName 'GrUsrCustomPolygon'; Procedure GrUsrPatternedLine(x1, y1, x2, y2: Integer; lp: GrLinePatternPtr); AsmName 'GrUsrPatternedLine'; Procedure GrUsrPatternedBox(x1, y1, x2, y2: Integer; lp: GrLinePatternPtr); AsmName 'GrUsrPatternedBox'; Procedure GrUsrPatternedCircle(xc, yc, r: Integer; lp: GrLinePatternPtr); AsmName 'GrUsrPatternedCircle'; Procedure GrUsrPatternedEllipse(xc, yc, xa, ya: Integer; lp: GrLinePatternPtr); AsmName 'GrUsrPatternedEllipse'; Procedure GrUsrPatternedCircleArc(xc, yc, r, start, ende, style: Integer; lp: GrLinePatternPtr); AsmName 'GrUsrPatternedCircleArc'; Procedure GrUsrPatternedEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; lp: GrLinePatternPtr); AsmName 'GrUsrPatternedEllipseArc'; Procedure GrUsrPatternedPolyLine(numpts: Integer; var Points{ : array of PointType }; lp: GrLinePatternPtr); AsmName 'GrUsrPatternedPolyLine'; Procedure GrUsrPatternedPolygon(numpts: Integer; var Points{ : array of PointType }; lp: GrLinePatternPtr); AsmName 'GrUsrPatternedPolygon'; Procedure GrUsrPatternFilledPlot(x, y: Integer; p: GrPatternPtr); AsmName 'GrPatternFilledPlot'; Procedure GrUsrPatternFilledLine(x1, y1, x2, y2: Integer; p: GrPatternPtr); AsmName 'GrUsrPatternFilledLine'; Procedure GrUsrPatternFilledBox(x1, y1, x2, y2: Integer; p: GrPatternPtr); AsmName 'GrUsrPatternFilledBox'; Procedure GrUsrPatternFilledCircle(xc, yc, r: Integer; p: GrPatternPtr); AsmName 'GrUsrPatternFilledCircle'; Procedure GrUsrPatternFilledEllipse(xc, yc, xa, ya: Integer; p: GrPatternPtr); AsmName 'GrUsrPatternFilledEllipse'; Procedure GrUsrPatternFilledCircleArc(xc, yc, r, start, ende, style: Integer; p: GrPatternPtr); AsmName 'GrUsrPatternFilledCircleArc'; Procedure GrUsrPatternFilledEllipseArc(xc, yc, xa, ya, start, ende, style: Integer; p: GrPatternPtr); AsmName 'GrUsrPatternFilledEllipseArc'; Procedure GrUsrPatternFilledConvexPolygon(numpts: Integer; var Points{ : array of PointType }; p: GrPatternPtr); AsmName 'GrUsrPatternFilledConvexPolygon'; Procedure GrUsrPatternFilledPolygon(numpts: Integer; var Points{ : array of PointType }; p: GrPatternPtr); AsmName 'GrUsrPatternFilledPolygon'; Procedure GrUsrPatternFloodFill(x, y: Integer; border: GrColor; p: GrPatternPtr); AsmName 'GrUsrPatternFloodFill'; Procedure GrUsrDrawChar(chr, x, y: Integer; protected var opt: GrTextOption); AsmName 'GrUsrDrawChar'; Procedure GrUsrDrawString(text: CString; length, x, y: Integer; protected var opt: GrTextOption); AsmName 'GrUsrDrawString'; Procedure GrUsrTextXY(x, y: Integer; text: CString; fg, bg: Integer); AsmName 'GrUsrTextXY'; { ================================================================== GRAPHICS CURSOR UTILITIES ================================================================== } Type { typedef struct _GR_cursor } GrCursor = record work : GrContext; { work areas (4) } xcord,ycord : Integer; { cursor position on screen } xsize,ysize : Integer; { cursor size } xoffs,yoffs : Integer; { LU corner to hot point offset } xwork,ywork : Integer; { save/work area sizes } xwpos,ywpos : Integer; { save/work area position on screen } displayed : Integer; { set if displayed } end; GrCursorPtr = ^GrCursor; Function GrBuildCursor(pixels: Pointer; pitch, w, h, xo, yo: Integer; protected var Colors { : array of GrColor }): GrCursorPtr; AsmName 'GrBuildCursor'; Procedure GrDestroyCursor(cursor: GrCursorPtr); AsmName 'GrDestroyCursor'; Procedure GrDisplayCursor(cursor: GrCursorPtr); AsmName 'GrDisplayCursor'; Procedure GrEraseCursor(cursor: GrCursorPtr); AsmName 'GrEraseCursor'; Procedure GrMoveCursor(cursor: GrCursorPtr; x, y: Integer); AsmName 'GrMoveCursor'; { ================================================================== } { MOUSE AND KEYBOARD INPUT UTILITIES } { ================================================================== } Const GR_M_MOTION = $0001; { mouse event flag bits } GR_M_LEFT_DOWN = $0002; GR_M_LEFT_UP = $0004; GR_M_RIGHT_DOWN = $0008; GR_M_RIGHT_UP = $0010; GR_M_MIDDLE_DOWN = $0020; GR_M_MIDDLE_UP = $0040; GR_M_BUTTON_DOWN = (GR_M_LEFT_DOWN or GR_M_MIDDLE_DOWN or GR_M_RIGHT_DOWN); GR_M_BUTTON_UP = (GR_M_LEFT_UP or GR_M_MIDDLE_UP or GR_M_RIGHT_UP); GR_M_BUTTON_CHANGE = (GR_M_BUTTON_UP or GR_M_BUTTON_DOWN); GR_M_LEFT = 1; { mouse button index bits } GR_M_RIGHT = 2; GR_M_MIDDLE = 4; GR_M_KEYPRESS = $0080; { other event flag bits } GR_M_POLL = $0100; GR_M_NOPAINT = $0200; GR_SIZE_CHANGED = $0400; GR_M_EVENT = (GR_M_MOTION or GR_M_KEYPRESS or GR_M_BUTTON_DOWN or GR_M_BUTTON_UP or GR_SIZE_CHANGED); GR_KB_RIGHTSHIFT = $01; { Keybd states: right shift key depressed } GR_KB_LEFTSHIFT = $02; { left shift key depressed } GR_KB_CTRL = $04; { CTRL depressed } GR_KB_ALT = $08; { ALT depressed } GR_KB_SCROLLOCK = $10; { SCROLL LOCK active } GR_KB_NUMLOCK = $20; { NUM LOCK active } GR_KB_CAPSLOCK = $40; { CAPS LOCK active } GR_KB_INSERT = $80; { INSERT state active } GR_KB_SHIFT = (GR_KB_LEFTSHIFT or GR_KB_RIGHTSHIFT); GR_M_CUR_NORMAL = 0; { MOUSE CURSOR modes: just the cursor } GR_M_CUR_RUBBER = 1; { rectangular rubber band (XOR-d to the screen) } GR_M_CUR_LINE = 2; { line attached to the cursor } GR_M_CUR_BOX = 3; { rectangular box dragged by the cursor } GR_M_CUR_CROSS = 4; { crosshair } GR_M_QUEUE_SIZE = 128; { default queue size } Type { typedef struct _GR_mouseEvent } { mouse event buffer structure } GrMouseEvent = record flags : Integer; { event type flags (see above) } x,y : Integer; { mouse coordinates } buttons : Integer; { mouse button state } key : Integer; { key code from keyboard } kbstat : Integer; { keybd status (ALT, CTRL, etc..) } dtime : Integer; { time since last event (msec) } end; GrMouseEventPtr = ^GrMouseEvent; Function GrMouseDetect: Boolean; AsmName 'GrMouseDetect'; Procedure GrMouseEventMode(dummy: Integer); AsmName 'GrMouseEventMode'; Procedure GrMouseInit; AsmName 'GrMouseInit'; Procedure GrMouseInitN(queue_size: Integer); AsmName 'GrMouseInitN'; Procedure GrMouseUnInit; AsmName 'GrMouseUnInit'; Procedure GrMouseSetSpeed(spmult, spdiv: Integer); AsmName 'GrMouseSetSpeed'; Procedure GrMouseSetAccel(thresh, accel: Integer); AsmName 'GrMouseSetAccel'; Procedure GrMouseSetLimits(x1, y1, x2, y2: Integer); AsmName 'GrMouseSetLimits'; Procedure GrMouseGetLimits(var x1, y1, x2, y2: Integer); AsmName 'GrMouseGetLimits'; Procedure GrMouseWarp(x, y: Integer); AsmName 'GrMouseWarp'; Procedure GrMouseEventEnable(enable_kb, enable_ms: Boolean); AsmName 'GrMouseEventEnable'; Procedure GrMouseGetEvent(flags: Integer; event: GrMouseEventPtr); AsmName 'GrMouseGetEvent'; Procedure GrMouseGetEventT(flags: Integer; event: GrMouseEventPtr; timout_msecs: Integer); AsmName 'GrMouseGetEventT'; Function GrMousePendingEvent: Integer; AsmName 'GrMousePendingEvent'; Function GrMouseGetCursor: GrCursorPtr; AsmName 'GrMouseGetCursor'; Procedure GrMouseSetCursor(cursor: GrCursorPtr); AsmName 'GrMouseSetCursor'; Procedure GrMouseSetColors(fg,bg: GrColor); AsmName 'GrMouseSetColors'; Procedure GrMouseSetCursorMode(mode: Integer; x1, y1, x2, y2: Integer; c: Integer); AsmName 'GrMouseSetCursorMode'; Procedure GrMouseDisplayCursor; AsmName 'GrMouseDisplayCursor'; Procedure GrMouseEraseCursor; AsmName 'GrMouseEraseCursor'; Procedure GrMouseUpdateCursor; AsmName 'GrMouseUpdateCursor'; Function GrMouseCursorIsDisplayed: Boolean; AsmName 'GrMouseCursorIsDisplayed'; Function GrMouseBlock(c: GrContextPtr; x1, y1, x2, y2: Integer): Integer; AsmName 'GrMouseBlock'; Procedure GrMouseUnBlock(return_value_from_GrMouseBlock: Integer); AsmName 'GrMouseUnBlock'; (* ================================================================== *) (* -------------- keyboard interface ---------------- *) (* ================================================================== *) const GrKey_NoKey = $0000; (* no key available *) GrKey_OutsideValidRange = $0100; (* key typed but code outside 1..GrKey_LastDefinedKeycode *) (* standard ASCII key codes *) GrKey_Control_A = $0001; GrKey_Control_B = $0002; GrKey_Control_C = $0003; GrKey_Control_D = $0004; GrKey_Control_E = $0005; GrKey_Control_F = $0006; GrKey_Control_G = $0007; GrKey_Control_H = $0008; GrKey_Control_I = $0009; GrKey_Control_J = $000a; GrKey_Control_K = $000b; GrKey_Control_L = $000c; GrKey_Control_M = $000d; GrKey_Control_N = $000e; GrKey_Control_O = $000f; GrKey_Control_P = $0010; GrKey_Control_Q = $0011; GrKey_Control_R = $0012; GrKey_Control_S = $0013; GrKey_Control_T = $0014; GrKey_Control_U = $0015; GrKey_Control_V = $0016; GrKey_Control_W = $0017; GrKey_Control_X = $0018; GrKey_Control_Y = $0019; GrKey_Control_Z = $001a; GrKey_Control_LBracket = $001b; GrKey_Control_BackSlash = $001c; GrKey_Control_RBracket = $001d; GrKey_Control_Caret = $001e; GrKey_Control_Underscore = $001f; GrKey_Space = $0020; GrKey_ExclamationPoint = $0021; GrKey_DoubleQuote = $0022; GrKey_Hash = $0023; GrKey_Dollar = $0024; GrKey_Percent = $0025; GrKey_Ampersand = $0026; GrKey_Quote = $0027; GrKey_LParen = $0028; GrKey_RParen = $0029; GrKey_Star = $002a; GrKey_Plus = $002b; GrKey_Comma = $002c; GrKey_Dash = $002d; GrKey_Period = $002e; GrKey_Slash = $002f; GrKey_0 = $0030; GrKey_1 = $0031; GrKey_2 = $0032; GrKey_3 = $0033; GrKey_4 = $0034; GrKey_5 = $0035; GrKey_6 = $0036; GrKey_7 = $0037; GrKey_8 = $0038; GrKey_9 = $0039; GrKey_Colon = $003a; GrKey_SemiColon = $003b; GrKey_LAngle = $003c; GrKey_Equals = $003d; GrKey_RAngle = $003e; GrKey_QuestionMark = $003f; GrKey_At = $0040; GrKey_A = $0041; GrKey_B = $0042; GrKey_C = $0043; GrKey_D = $0044; GrKey_E = $0045; GrKey_F = $0046; GrKey_G = $0047; GrKey_H = $0048; GrKey_I = $0049; GrKey_J = $004a; GrKey_K = $004b; GrKey_L = $004c; GrKey_M = $004d; GrKey_N = $004e; GrKey_O = $004f; GrKey_P = $0050; GrKey_Q = $0051; GrKey_R = $0052; GrKey_S = $0053; GrKey_T = $0054; GrKey_U = $0055; GrKey_V = $0056; GrKey_W = $0057; GrKey_X = $0058; GrKey_Y = $0059; GrKey_Z = $005a; GrKey_LBracket = $005b; GrKey_BackSlash = $005c; GrKey_RBracket = $005d; GrKey_Caret = $005e; GrKey_UnderScore = $005f; GrKey_BackQuote = $0060; GrKey_small_a = $0061; GrKey_small_b = $0062; GrKey_small_c = $0063; GrKey_small_d = $0064; GrKey_small_e = $0065; GrKey_small_f = $0066; GrKey_small_g = $0067; GrKey_small_h = $0068; GrKey_small_i = $0069; GrKey_small_j = $006a; GrKey_small_k = $006b; GrKey_small_l = $006c; GrKey_small_m = $006d; GrKey_small_n = $006e; GrKey_small_o = $006f; GrKey_small_p = $0070; GrKey_small_q = $0071; GrKey_small_r = $0072; GrKey_small_s = $0073; GrKey_small_t = $0074; GrKey_small_u = $0075; GrKey_small_v = $0076; GrKey_small_w = $0077; GrKey_small_x = $0078; GrKey_small_y = $0079; GrKey_small_z = $007a; GrKey_LBrace = $007b; GrKey_Pipe = $007c; GrKey_RBrace = $007d; GrKey_Tilde = $007e; GrKey_Control_Backspace = $007f; (* extended key codes as defined in DJGPP *) GrKey_Alt_Escape = $0101; GrKey_Control_At = $0103; GrKey_Alt_Backspace = $010e; GrKey_BackTab = $010f; GrKey_Alt_Q = $0110; GrKey_Alt_W = $0111; GrKey_Alt_E = $0112; GrKey_Alt_R = $0113; GrKey_Alt_T = $0114; GrKey_Alt_Y = $0115; GrKey_Alt_U = $0116; GrKey_Alt_I = $0117; GrKey_Alt_O = $0118; GrKey_Alt_P = $0119; GrKey_Alt_LBracket = $011a; GrKey_Alt_RBracket = $011b; GrKey_Alt_Return = $011c; GrKey_Alt_A = $011e; GrKey_Alt_S = $011f; GrKey_Alt_D = $0120; GrKey_Alt_F = $0121; GrKey_Alt_G = $0122; GrKey_Alt_H = $0123; GrKey_Alt_J = $0124; GrKey_Alt_K = $0125; GrKey_Alt_L = $0126; GrKey_Alt_Semicolon = $0127; GrKey_Alt_Quote = $0128; GrKey_Alt_Backquote = $0129; GrKey_Alt_Backslash = $012b; GrKey_Alt_Z = $012c; GrKey_Alt_X = $012d; GrKey_Alt_C = $012e; GrKey_Alt_V = $012f; GrKey_Alt_B = $0130; GrKey_Alt_N = $0131; GrKey_Alt_M = $0132; GrKey_Alt_Comma = $0133; GrKey_Alt_Period = $0134; GrKey_Alt_Slash = $0135; GrKey_Alt_KPStar = $0137; GrKey_F1 = $013b; GrKey_F2 = $013c; GrKey_F3 = $013d; GrKey_F4 = $013e; GrKey_F5 = $013f; GrKey_F6 = $0140; GrKey_F7 = $0141; GrKey_F8 = $0142; GrKey_F9 = $0143; GrKey_F10 = $0144; GrKey_Home = $0147; GrKey_Up = $0148; GrKey_PageUp = $0149; GrKey_Alt_KPMinus = $014a; GrKey_Left = $014b; GrKey_Center = $014c; GrKey_Right = $014d; GrKey_Alt_KPPlus = $014e; GrKey_End = $014f; GrKey_Down = $0150; GrKey_PageDown = $0151; GrKey_Insert = $0152; GrKey_Delete = $0153; GrKey_Shift_F1 = $0154; GrKey_Shift_F2 = $0155; GrKey_Shift_F3 = $0156; GrKey_Shift_F4 = $0157; GrKey_Shift_F5 = $0158; GrKey_Shift_F6 = $0159; GrKey_Shift_F7 = $015a; GrKey_Shift_F8 = $015b; GrKey_Shift_F9 = $015c; GrKey_Shift_F10 = $015d; GrKey_Control_F1 = $015e; GrKey_Control_F2 = $015f; GrKey_Control_F3 = $0160; GrKey_Control_F4 = $0161; GrKey_Control_F5 = $0162; GrKey_Control_F6 = $0163; GrKey_Control_F7 = $0164; GrKey_Control_F8 = $0165; GrKey_Control_F9 = $0166; GrKey_Control_F10 = $0167; GrKey_Alt_F1 = $0168; GrKey_Alt_F2 = $0169; GrKey_Alt_F3 = $016a; GrKey_Alt_F4 = $016b; GrKey_Alt_F5 = $016c; GrKey_Alt_F6 = $016d; GrKey_Alt_F7 = $016e; GrKey_Alt_F8 = $016f; GrKey_Alt_F9 = $0170; GrKey_Alt_F10 = $0171; GrKey_Control_Print = $0172; GrKey_Control_Left = $0173; GrKey_Control_Right = $0174; GrKey_Control_End = $0175; GrKey_Control_PageDown = $0176; GrKey_Control_Home = $0177; GrKey_Alt_1 = $0178; GrKey_Alt_2 = $0179; GrKey_Alt_3 = $017a; GrKey_Alt_4 = $017b; GrKey_Alt_5 = $017c; GrKey_Alt_6 = $017d; GrKey_Alt_7 = $017e; GrKey_Alt_8 = $017f; GrKey_Alt_9 = $0180; GrKey_Alt_0 = $0181; GrKey_Alt_Dash = $0182; GrKey_Alt_Equals = $0183; GrKey_Control_PageUp = $0184; GrKey_F11 = $0185; GrKey_F12 = $0186; GrKey_Shift_F11 = $0187; GrKey_Shift_F12 = $0188; GrKey_Control_F11 = $0189; GrKey_Control_F12 = $018a; GrKey_Alt_F11 = $018b; GrKey_Alt_F12 = $018c; GrKey_Control_Up = $018d; GrKey_Control_KPDash = $018e; GrKey_Control_Center = $018f; GrKey_Control_KPPlus = $0190; GrKey_Control_Down = $0191; GrKey_Control_Insert = $0192; GrKey_Control_Delete = $0193; GrKey_Control_Tab = $0194; GrKey_Control_KPSlash = $0195; GrKey_Control_KPStar = $0196; GrKey_Alt_KPSlash = $01a4; GrKey_Alt_Tab = $01a5; GrKey_Alt_Enter = $01a6; (* some additional codes not in DJGPP *) GrKey_Alt_LAngle = $01b0; GrKey_Alt_RAngle = $01b1; GrKey_Alt_At = $01b2; GrKey_Alt_LBrace = $01b3; GrKey_Alt_Pipe = $01b4; GrKey_Alt_RBrace = $01b5; GrKey_Print = $01b6; GrKey_Shift_Insert = $01b7; GrKey_Shift_Home = $01b8; GrKey_Shift_End = $01b9; GrKey_Shift_PageUp = $01ba; GrKey_Shift_PageDown = $01bb; GrKey_Alt_Up = $01bc; GrKey_Alt_Left = $01bd; GrKey_Alt_Center = $01be; GrKey_Alt_Right = $01c0; GrKey_Alt_Down = $01c1; GrKey_Alt_Insert = $01c2; GrKey_Alt_Delete = $01c3; GrKey_Alt_Home = $01c4; GrKey_Alt_End = $01c5; GrKey_Alt_PageUp = $01c6; GrKey_Alt_PageDown = $01c7; GrKey_Shift_Up = $01c8; GrKey_Shift_Down = $01c9; GrKey_Shift_Right = $01ca; GrKey_Shift_Left = $01cb; (* this may be usefull for table allocation ... *) GrKey_LastDefinedKeycode = GrKey_Shift_Left; (* some well known synomyms *) GrKey_BackSpace = GrKey_Control_H; GrKey_Tab = GrKey_Control_I; GrKey_LineFeed = GrKey_Control_J; GrKey_Escape = GrKey_Control_LBracket; GrKey_Return = GrKey_Control_M; Type GrKeyType = ShortInt; (* ** new functions to replace the old style ** kbhit / getch / getkey / getxkey / getkbstat ** keyboard interface *) Function GrKeyPressed: Integer; AsmName 'GrKeyPressed'; Function GrKeyRead: GrKeyType; AsmName 'GrKeyRead'; Function GrKeyStat: Integer; AsmName 'GrKeyStat'; (* ================================================================== *) (* MISCELLANEOUS UTILITIY FUNCTIONS *) (* ================================================================== *) procedure GrResizeGrayMap (var Map; pitch, ow, oh, nw, nh: Integer); AsmName 'GrResizeGrayMap'; function GrMatchString (Pattern, strg: CString): Integer; AsmName 'GrMatchString'; procedure GrSetWindowTitle (Title: CString); AsmName 'GrSetWindowTitle'; procedure GrSleep (msec: Integer); AsmName 'GrSleep'; (* ================================================================== *) (* PNM FUNCTIONS *) (* ================================================================== *) (* * The PNM formats, grx support load/save of * binaries formats (4,5,6) only *) const PLAINPBMFORMAT = 1; PLAINPGMFORMAT = 2; PLAINPPMFORMAT = 3; PBMFORMAT = 4; PGMFORMAT = 5; PPMFORMAT = 6; (* The PNM functions *) Function GrSaveContextToPbm (grc : GrContextPtr; FileName, Comment: CString): Integer; AsmName 'GrSaveContextToPbm'; Function GrSaveContextToPgm (grc : GrContextPtr; FileName, Comment: CString): Integer; AsmName 'GrSaveContextToPgm'; Function GrSaveContextToPpm (grc : GrContextPtr; FileName, Comment: CString): Integer; AsmName 'GrSaveContextToPpm'; Function GrLoadContextFromPnm (grc : GrContextPtr; FileName: CString): Integer; AsmName 'GrLoadContextFromPnm'; Function GrQueryPnm (FileName: CString; var Width, Height, MaxVal: Integer): Integer; AsmName 'GrQueryPnm'; Function GrLoadContextFromPnmBuffer (grc : GrContextPtr; protected var Buffer): Integer; AsmName 'GrLoadContextFromPnmBuffer'; Function GrQueryPnmBuffer (protected var Buffer; var Width, Height, MaxVal: Integer): Integer; AsmName 'GrQueryPnmBuffer'; (* ================================================================== *) (* ADDON FUNCTIONS *) (* these functions may not be installed or available on all system *) (* ================================================================== *) Function GrPngSupport: Integer; AsmName 'GrPngSupport'; Function GrSaveContextToPng (grc : GrContextPtr; FileName: CString): Integer; AsmName 'GrSaveContextToPng'; Function GrLoadContextFromPng (grc : GrContextPtr; FileName: CString; UseAlpha: Integer): Integer; AsmName 'GrLoadContextFromPng'; Function GrQueryPng (FileName: CString; var Width, Height: Integer): Integer; AsmName 'GrQueryPng'; (* ** SaveContextToTiff - Dump a context in a TIFF file ** ** Arguments: ** cxt: Context to be saved (NIL -> use current context) ** tiffn: Name of tiff file ** compr: Compression method (see tiff.h), 0: automatic selection ** docn: string saved in the tiff file (DOCUMENTNAME tag) ** ** Returns 0 on success ** -1 on error ** ** requires tifflib by Sam Leffler (sam@engr.sgi.com) ** available at ftp://ftp.sgi.com/graphics/tiff *) Function SaveContextToTiff(cxt: GrContextPtr; tiffn: CString; compr: Integer; docn: CString) : Integer; AsmName 'SaveContextToTiff'; (* ** GrSaveContextToJpeg - Dump a context in a JPEG file ** ** Arguments: ** grc: Context to be saved (NIL -> use current context) ** Filename: Name of the jpeg file ** accuracy: Accuracy percentage (100 for no loss of quality) ** ** Returns 0 on success ** -1 on error ** ** requires jpeg-6a by IJG (Independent JPEG Group) ** available at ftp.uu.net as graphics/jpeg/jpegsrc.v6a.tar.gz *) Function GrSaveContextToJpeg(grc : GrContextPtr; FileName: CString; accuracy: Integer) : Integer; AsmName 'GrSaveContextToJpeg'; Function GrSaveContextToGrayJpeg(grc : GrContextPtr; FileName: CString; accuracy: Integer) : Integer; AsmName 'GrSaveContextToGrayJpeg'; Function GrJpegSupport: integer; AsmName 'GrJpegSupport'; Function GrLoadContextFromJpeg(grc : GrContextPtr; FileName: CString; scale: Integer) : Integer; AsmName 'GrLoadContextFromJpeg'; Function GrQueryJpeg(FileName: CString; var width, height: Integer) : Integer; AsmName 'GrQueryJpeg'; Implementation end.