Grx August 2000

grx@gnu.de

7 participants
15 discussions

GRX fonts.
by Mohamed Aly 01 Sep '00

01 Sep '00

I recently ported a DOS program from Borland to the DJGPP/GRX environment. I was looking for fonts for the GRX library. What font type should I look for? Is it GEM? Where to find more fonts or font utilities/editors to port my old MS WINDOWS fonts? Mohamed Aly

2 1

GRX user's manual 8
by Mariano Alvarez Fernandez 30 Aug '00

30 Aug '00

Hi, the last part. I need help with two functions: GrImage *GrImageBuild(char *pixels,int w,int h,GrColorTableP colors); GrImage *GrImageBuildUsedAsPattern(char *pixels,int w,int h, GrColorTableP colors); they do the same, but GrImageBuildUsedAsPattern calls GrBuildPixmap and GrImageBuild is a real function. I don't know why. I have put the whole new user's manual zipped here: http://www.terra.es/personal/malfer/grx/resourc.htm I'm waiting for comments. … [View More]Gretings, M.Alvarez * Image manipulation (next to patterned line drawing) GRX defines the GrImage type like a GrPixmap synonym: #define GrImage GrPixmap nevertheless the GrImage type enforces the image character of this object, so for compatibility with future GRX versions use the next functions if you need to convert between 'GrImage' and 'GrPixmap' objects: GrImage *GrImageFromPattern(GrPattern *p); GrPattern *GrPatternFromImage(GrImage *p); the 'GrImageFromPattern' function returns NULL if the 'GrPattern' given is not a 'GrPixmap'. Like pixmaps patterns images are dependent of the actual video mode set. So the library provides functions to create images in a mode-independent way: GrImage *GrImageBuild(char *pixels,int w,int h,GrColorTableP colors); GrImage *GrImageFromContext(GrContext *c); these functions work like the 'GrBuildPixmap' and 'GrConvertToPixmap' ones. Remember: the image and the original context share the drawing RAM. There are a number of functions to display all or part of an image in the current context: void GrImageDisplay(int x,int y, GrImage *i); void GrImageDisplayExt(int x1,int y1,int x2,int y2, GrImage *i); void GrImageFilledBoxAlign(int xo,int yo,int x1,int y1,int x2,int y2, GrImage *p); void GrImageHLineAlign(int xo,int yo,int x,int y,int width,GrImage *p); void GrImagePlotAlign(int xo,int yo,int x,int y,GrImage *p); 'GrImageDisplay' display the whole image using 'x', 'y' like the upper left corner in the current context. 'GrImageDisplayExt' display as much as it can (repiting the image if necesary) in the rectangle defined by 'x1', 'y1' and 'x2', 'y2'. 'GrImageFilledBoxAlign' is a most general funtion (really the later two call it) display as much as it can in the defined rectangle using 'xo', 'yo' like the align point, it is the virtual point in the destination context (it doesn't need to be into the rectangle) with that the upper left image corner is aligned. 'GrImageHLineAlign' and 'GrImagePlotAlign' display a row segment or a point of the image at 'x' 'y' position using the 'xo', 'yo' allign point. The most usefull image funtions are these: GrImage *GrImageInverse(GrImage *p,int flag); GrImage *GrImageStretch(GrImage *p,int nwidth,int nheight); 'GrImageInverse' creates a new image object, flipping 'p' left-right or top-down as indicated by 'flag' that can be: #define GR_IMAGE_INVERSE_LR 0x01 /* inverse left right */ #define GR_IMAGE_INVERSE_TD 0x02 /* inverse top down */ 'GrImageStretch' creates a new image stretching 'p' to 'nwidth' by 'nheight'. To destroy a image objet when you don't need it any more use: void GrImageDestroy(GrImage *i); * (at the end of More Graphics primitives) A efficient form to get/put pixels from/to a context can be achieved using the next functions: const GrColor *GrGetScanline(int x1,int x2,int yy); const GrColor *GrGetScanlineC(GrContext *ctx,int x1,int x2,int yy); void GrPutScanline(int x1,int x2,int yy,const GrColor *c, GrColor op); The 'Get' functions return a pointer to a static GrColor pixel array (or NULL if they fail) with the color values of a row ('yy') segment ('x1' to 'x2'). 'GrGetScanline' uses the current context. 'GrGestScanlineC' uses the context 'ctx' (that can be NULL to refer to the current context). Note that the output is only valid until the next GRX call. 'GrPutScanline' puts the GrColor pixel array 'c' on the 'yy' row segmet defined by 'x1' to 'x2' in the current context using the 'op' operation. 'op' can be any of 'GrWRITE', 'GrXOR', 'GrOR' 'GrAND' or 'GrIMAGE'. Data in 'c' must fit 'GrCVALUEMASK' otherwise the results are implementation dependend. So you can't supply operation code with the pixel data!. [View Less]

1 0

GRX user's manual 7
by Mariano Alvarez Fernandez 29 Aug '00

29 Aug '00

Not the last, I want to document Image functions too (but I need to try). Please, I want to know if you found things not OK. * Mouse event handling All mouse services need the presence of a mouse. An application can test whether a mouse is available by calling the function: int GrMouseDetect(void); which will return zero if no mouse (or mouse driver) is present, non-zero otherwise. The mouse must be initialized by calling one (and only one) of these functions: void GrMouseInit(void); … [View More]void GrMouseInitN(int queue_size); 'GrMouseInit' sets a event queue (see below) size to 'GR_M_QUEU_SIZE' (128). A user supply event queue size can be set calling 'GrMouseInitN' instead. It is a good practice to call 'GrMouseUnInit' before exiting the program. This will restore any interrupt vectors hooked by the program to their original values. void GrMouseUnInit(void); The mouse can be controlled with the following functions: void GrMouseSetSpeed(int spmult,int spdiv); void GrMouseSetAccel(int thresh,int accel); void GrMouseSetLimits(int x1,int y1,int x2,int y2); void GrMouseGetLimits(int *x1,int *y1,int *x2,int *y2); void GrMouseWarp(int x,int y); The library calculates the mouse position only from the mouse mickey counters. (To avoid the limit and 'rounding to the next multiple of eight' problem with some mouse driver when it finds itself in a graphics mode unknown to it.) The parameters to the 'GrMouseSetSpeed' function specify how coordinate changes are obtained from mickey counter changes, multipling by 'spmult' and dividing by 'spdiv'. In high resolution graphics modes the value of one just works fine, in low resolution modes (320x200 or similar) it is best set the 'spdiv' to two or three. (Of course, it also depends on the sensitivity the mouse.) The 'GrMouseSetAccel' function is used to control the ballistic effect: if a mouse coordinate changes between two samplings by more than the 'thresh' parameter, the change is multiplied by the 'accel' parameter. NOTE: some mouse drivers perform similar calculations before reporting the coordinates in mickeys. In this case the acceleration done by the library will be additional to the one already performed by the mouse driver. The limits of the mouse movement can be set (passed limits will be clipped to the screen) with 'GrMouseSetLimits' (default is the whole screen) and the current limits can be obtained with 'GrMouseGetLimits'. 'GrMouseWarp' sets the mouse cursor to the specified position. As typical mouse drivers do not know how to draw mouse cursors in high resolution graphics modes, the mouse cursor is drawn by the library. The mouse cursor can be set with: void GrMouseSetCursor(GrCursor *cursor); void GrMouseSetColors(GrColor fg,GrColor bg); 'GrMouseSetColors' uses an internal arrow pattern, the color 'fg' will be used as the interior of it and 'bg' will be the border. The current mouse cursor can be obtained with: GrCursor *GrMouseGetCursor(void); The mouse cursor can be displayed/erased with: void GrMouseDisplayCursor(void); void GrMouseEraseCursor(void); The mouse cursor can be left permanently displayed. All graphics primitives except for the few non-clipping functions check for conflicts with the mouse cursor and erase it before the drawing if necessary. Of course, it may be more efficient to erase the cursor manually before a long drawing sequence and redraw it after completion. The library provides an alternative pair of calls for this purpose which will erase the cursor only if it interferes with the drawing: int GrMouseBlock(GrContext *c,int x1,int y1,int x2,int y2); void GrMouseUnBlock(int return_value_from_GrMouseBlock); 'GrMouseBlock' should be passed the context in which the drawing will take place (the usual convention of NULL meaning the current context is supported) and the limits of the affected area. It will erase the cursor only if it interferes with the drawing. When the drawing is finished 'GrMouseUnBlock' must be called with the argument returned by 'GrMouseBlock'. The status of the mouse cursor can be obtained with calling 'GrMouseCursorIsDisplayed'. This function will return non-zero if the cursor is displayed, zero if it is erased. int GrMouseCursorIsDisplayed(void); The library supports (beside the simple cursor drawing) three types of "rubberband" attached to the mouse cursor. The 'GrMouseSetCursorMode' function is used to select the cursor drawing mode. void GrMouseSetCursorMode(int mode,...); The parameter 'mode' can have the following values: #define GR_M_CUR_NORMAL 0 /* MOUSE CURSOR modes: just the cursor */ #define GR_M_CUR_RUBBER 1 /* rect. rubber band (XOR-d to the screen) */ #define GR_M_CUR_LINE 2 /* line attached to the cursor */ #define GR_M_CUR_BOX 3 /* rectangular box dragged by the cursor */ 'GrMouseSetCursorMode' takes different parameters depending on the cursor drawing mode selected. The accepted call formats are: GrMouseSetCursorMode(M_CUR_NORMAL); GrMouseSetCursorMode(M_CUR_RUBBER,xanchor,yanchor,GrColor); GrMouseSetCursorMode(M_CUR_LINE,xanchor,yanchor,GrColor); GrMouseSetCursorMode(M_CUR_BOX,dx1,dy1,dx2,dy2,GrColor); The anchor parameters for the rubberband and rubberline modes specify a fixed screen location to which the other corner of the primitive is bound. The 'dx1' through 'dy2' parameters define the offsets of the corners of the dragged box from the hotpoint of the mouse cursor. The color value passed is always XOR-ed to the screen, i.e. if an application wants the rubberband to appear in a given color on a given background then it has to pass the XOR of these two colors to 'GrMouseSetCursorMode'. The 'GrMouseGetEvent' function is used to obtain the next mouse or keyboard event. It takes a flag with various bits encoding the type of event needed. It returns the event in a 'GrMouseEvent' structure. The relevant declarations from "grx20.h": void GrMouseGetEvent(int flags,GrMouseEvent *event); typedef struct _GR_mouseEvent { /* mouse event buffer structure */ int flags; /* event type flags (see above) */ int x,y; /* mouse coordinates */ int buttons; /* mouse button state */ int key; /* key code from keyboard */ int kbstat; /* keybd status (ALT, CTRL, etc..) */ long dtime; /* time since last event (msec) */ } GrMouseEvent; The event structure has been extended with a keyboard status word (thus a program can check for combinations like ALT-<left mousebutton press>) and a time stamp which can be used to check for double clicks, etc... The following macros have been defined in "grx20.h" to help in creating the control flag for 'GrMouseGetEvent' and decoding the various bits in the event structure: #define GR_M_MOTION 0x001 /* mouse event flag bits */ #define GR_M_LEFT_DOWN 0x002 #define GR_M_LEFT_UP 0x004 #define GR_M_RIGHT_DOWN 0x008 #define GR_M_RIGHT_UP 0x010 #define GR_M_MIDDLE_DOWN 0x020 #define GR_M_MIDDLE_UP 0x040 #define GR_M_BUTTON_DOWN (GR_M_LEFT_DOWN | GR_M_MIDDLE_DOWN | \ GR_M_RIGHT_DOWN) #define GR_M_BUTTON_UP (GR_M_LEFT_UP | GR_M_MIDDLE_UP | \ GR_M_RIGHT_UP) #define GR_M_BUTTON_CHANGE (GR_M_BUTTON_UP | GR_M_BUTTON_DOWN ) #define GR_M_LEFT 1 /* mouse button index bits */ #define GR_M_RIGHT 2 #define GR_M_MIDDLE 4 #define GR_M_KEYPRESS 0x080 /* other event flag bits */ #define GR_M_POLL 0x100 #define GR_M_NOPAINT 0x200 #define GR_M_EVENT (GR_M_MOTION | GR_M_KEYPRESS | \ GR_M_BUTTON_DOWN | GR_M_BUTTON_UP) 'GrMouseGetEvent' will display the mouse cursor if it was previously erased and the 'GR_M_NOPAINT' bit is not set in the flag passed to it. In this case it will also erase the cursor after an event has been obtained. 'GrMouseGetEvent' block until a event is produced, except if the 'GR_M_POLL' bit is set in the falg passed to it. Another version of GetEvent: void GrMouseGetEventT(int flags,GrMouseEvent *event,long timout_msecs); can be istructed to wait timout_msec for the presence of an event. Note that event->dtime is only valid if any event occured (event->flags !=0) otherwise it's set as -1. Additionally event timing is real world time even in X11 && Linux. If there are one or more events waiting the function: int GrMousePendingEvent(void); returns non-zero value. The generation of mouse and keyboard events can be individually enabled or disabled (by passing a non-zero or zero, respectively, value in the corresponding 'enable_XX' parameter) by calling: void MouseEventEnable(int enable_kb,int enable_ms); Note that 'GrMouseInit' set both by default. [View Less]

1 0

Suggestion
by Josu Onandia 28 Aug '00

28 Aug '00

Hi everybody, I'm using GRX in an embedded system. Here is very important to make the difference between 'initialized data' and 'constant data'. Unfortunately this is not the case in the Grx sources, and I've had to put the keyword 'const' in several places to save Ram space. I believe this change is not only interesting for people doing embedded systems, but also for the rest of you, because code gets cleaner and it will improve the long term development and maintenance. This is the list of … [View More]

1 0

testing
by Gary Lloyd 27 Aug '00

27 Aug '00

testing

1 0

GRX user's manual 6
by Mariano Alvarez Fernandez 27 Aug '00

27 Aug '00

About cursors and GrKeys * Graphics cursors The library provides support for the creation and usage of an unlimited number of graphics cursors. An application can use these cursors for any purpose. Cursors always save the area they occupy before they are drawn. When moved or erased they restore this area. As a general rule of thumb, an application should erase a cursor before making changes to an area it occupies and redraw the cursor after finishing the drawing. Cursors are created with the … [View More]'GrBuildCursor' function: GrCursor *GrBuildCursor(char far *pixels,int pitch,int w,int h, int xo,int yo,GrColorTableP c); GrCursor *GrBuildCursor(char *data,int w,int h,int xo,int yo,GrColorTableP c); The 'pixels', 'w' (=width), 'h' (=height) and 'c' (= color table) arguments are similar to the arguments of the pixmap building library function 'GrBuildPixmap' (see that paragraph for a more detailed explanation.), but with two differences. First, is not assumed that the pixels data is 'w' x 'h' sized, the 'pitch'argument set the offset between rows. Second, the pixmap data is interpreted slightly differently, any pixel with value zero is taken as a "transparent" pixel, i.e. the background will show through the cursor pattern at that pixel. A pixmap data byte with value = 1 will refer to the first color in the table, and so on. The 'xo' (= X offset) and 'yo' (= Y offset) arguments specify the position (from the top left corner of the cursor pattern) of the cursor's "hot point". The 'GrCursor' data structure: typedef struct _GR_cursor { struct _GR_context work; /* work areas (4) */ int xcord,ycord; /* cursor position on screen */ int xsize,ysize; /* cursor size */ int xoffs,yoffs; /* LU corner to hot point offset */ int xwork,ywork; /* save/work area sizes */ int xwpos,ywpos; /* save/work area position on screen */ int displayed; /* set if displayed */ } GrCursor; is typically not used (i.e. read or changed) by the application program, it should just pass pointers to these structures to the appropriate library functions. Other cursor manipulation functions: void GrDisplayCursor(GrCursor *cursor); void GrEraseCursor(GrCursor *cursor); void GrMoveCursor(GrCursor *cursor,int x,int y); void GrDestroyCursor(GrCursor *cursor); * Keyboard input GRX can handle platform independant key input. The file "grxkeys.h" defines the keys to be used in the user's program. This is an extract: #define GrKey_Control_A 0x0001 #define GrKey_Control_B 0x0002 #define GrKey_Control_C 0x0003 ... #define GrKey_A 0x0041 #define GrKey_B 0x0042 #define GrKey_C 0x0043 ... #define GrKey_F1 0x013b #define GrKey_F2 0x013c #define GrKey_F3 0x013d ... #define GrKey_Alt_F1 0x0168 #define GrKey_Alt_F2 0x0169 #define GrKey_Alt_F3 0x016a But you can be confident that the standard ASCII is right maped. The 'GrKeyType' type is defined to store keycodes: typedef unsigned short GrKeyType; This function: int GrKeyPressed(void); returns non zero if there are any keycode waiting, that can be read with: GrKeyType GrKeyRead(void); The function: int GrKeyStat(void); returns a keyboard status word, or-ing it with the next defines it can be known the status of some special keys: #define GR_KB_RIGHTSHIFT 0x01 /* right shift key depressed */ #define GR_KB_LEFTSHIFT 0x02 /* left shift key depressed */ #define GR_KB_CTRL 0x04 /* CTRL depressed */ #define GR_KB_ALT 0x08 /* ALT depressed */ #define GR_KB_SCROLLOCK 0x10 /* SCROLL LOCK active */ #define GR_KB_NUMLOCK 0x20 /* NUM LOCK active */ #define GR_KB_CAPSLOCK 0x40 /* CAPS LOCK active */ #define GR_KB_INSERT 0x80 /* INSERT state active */ #define GR_KB_SHIFT (GR_KB_LEFTSHIFT | GR_KB_RIGHTSHIFT) [View Less]

1 0

Re: GRX user's manual 5
by Mariano Alvarez Fernandez 27 Aug '00

27 Aug '00

richard(a)stardate.bc.ca escribió: > Hi Mariano; > A minor change. > > > void GrDumpFont(GrFont *f,char *CsymbolName,char *fileName); > > > > write a font to file like C code, so it can be linked with a user program. > > Should be..... > writes a font to a C source code file, so it can be compiled and > linked with a user program. > Thanks > > I had to try the function to see what it produced. Could I suggest a > small … [View More]

1 0

GRX user's manual
by Mariano Alvarez Fernandez 26 Aug '00

26 Aug '00

Hi. I'm working in put up to date the GRX user's manual, attached to this mail is the first part, about video modes and context. Any comment will be apreciated. Greetings, M.Alvarez GRX 2.3 A graphics library for DOS, Linux and X11 User's Manual August 17, 2000 Based on the original doc written by: Csaba Biegl August 10, 1992 ---- Abstract LIBGRX is a graphics library for DOS (DJGPP v2 and Turbo C/Borland C++ versions), Linux and X11. On DOS it supports VGA (32768, 256 or 16 … [View More]colors), EGA (16 colors), and VESA compliant cards (up to 16M colors). On Linux console it uses svgalib. On X11 it must work on any X11R5 (or later). Data types, function declarations All public data structures and graphics primitives meant for usage by the application program are declared/prototyped in the header files (in the 'include' sub-directory): grdriver.h graphics driver format specifications grfontdv.h format of a font when loaded into memory grx20.h drawing-related structures and functions grxkeys.h platform independent key definitions User programs normally only include grx20.h and grxkeys.h Setting the graphics driver The graphics driver is normally set by the final user by the environment variable GRX20DRV, but a program can set it using: int GrSetDriver(char *drvspec); The drvspec string has the same format as the environment variable: "<driver> gw <width> gh <height> nc <colors>" Available drivers are for DOS : stdvga, stdega, et4000, cl5426, mach64, ati28800, VESA, memory Linux: svgalib, memory X11 : xwin, memory The optionals gw, gh and nc parameters set the desired default graphics mode. Normal values for 'nc' are 2, 16, 256, 64K and 16M. The current driver name can be obtained from: GrCurrentVideoDriver()->name Setting video modes Before a program can do any graphics drawing it has to configure the graphics driver for the desired graphics mode. It is done with the 'GrSetMode' function as follows: void GrSetMode(int which,...); The 'which' parameter can be one of the following constants, declared in "grx20.h": typedef enum _GR_graphicsModes { GR_80_25_text, GR_default_text, GR_width_height_text, GR_biggest_text, GR_320_200_graphics, GR_default_graphics, GR_width_height_graphics, GR_biggest_noninterlaced_graphics, GR_biggest_graphics, GR_width_height_color_graphics, GR_width_height_color_text, GR_custom_graphics, GR_width_height_bpp_graphics, GR_width_height_bpp_text, GR_custom_bpp_graphics, GR_NC_80_25_text, GR_NC_default_text, GR_NC_width_height_text, GR_NC_biggest_text, GR_NC_320_200_graphics, GR_NC_default_graphics, GR_NC_width_height_graphics, GR_NC_biggest_noninterlaced_graphics, GR_NC_biggest_graphics, GR_NC_width_height_color_graphics, GR_NC_width_height_color_text, GR_NC_custom_graphics, GR_NC_width_height_bpp_graphics, GR_NC_width_height_bpp_text, GR_NC_custom_bpp_graphics, } GrGraphicsMode; The 'GR_width_height_text' and 'GR_width_height_graphics' modes require the two size arguments: int width and int height. The 'GR_width_height_color_graphics' and 'GR_width_height_color_text' modes require three arguments: int width, int height and GrColor colors. The 'GR_width_height_bpp_graphics' and 'GR_width_height_bpp_text' modes require three arguments: int width, int height and int bpp (bits per plane instead number of colors). The 'GR_custom_graphics' and 'GR_custom_bpp_graphics' modes require five arguments: int width, int height, GrColor colors or int bpp, int vx and int vy. Using this modes you can set a virtual screen of 'vx' by 'vy' size. A call with any other mode does not require any arguments. The 'GR_NC_...' modes are equivalent to the 'GR_..' ones, but they don't clear the video memory. Graphics drivers can provide info of the supported graphics modes, use the next code skeleton to colect the data: { GrFrameMode fm; const GrVideoMode *mp; for(fm =GR_firstGraphicsFrameMode; fm <= GR_lastGraphicsFrameMode; fm++) { mp = GrFirstVideoMode(fm); while( mp != NULL ){ .. .. use the mp info .. mp = GrNextVideoMode(mp)) } } } Don't worry if you don't understand it, normal user programs don't need to know about FrameModes. The GrVideoMode structure has the following fields: typedef struct _GR_videoMode GrVideoMode; struct _GR_videoMode { char present; /* is it really available? */ char bpp; /* log2 of # of colors */ short width,height; /* video mode geometry */ short mode; /* BIOS mode number (if any) */ int lineoffset; /* scan line length */ int privdata; /* driver can use it for anything */ struct _GR_videoModeExt *extinfo; /* extra info (maybe shared) */ }; The width, height and bpp members are the useful information if you are interested in set modes other than the 'GR_default_graphics'. A user-defined function can be invoked every time the video mode is changed (i.e. 'GrSetMode' is called). This function should not take any parameters and don't return any value. It can be installed (for all subsequent 'GrSetMode' calls) with the: void GrSetModeHook(void (*hookfunc)(void)); function. The current graphics mode (one of the valid 'mode' argument values for 'GrSetMode') can be obtained with the: GrGraphicsMode GrCurrentMode(void); function, while the type of the installed graphics adapter can be determined with the GrVideoAdapter GrAdapterType(void); function. 'GrAdapterType' returns the type of the adapter as one of the following symbolic constants (defined in "grx20.h"): typedef enum _GR_videoAdapters { GR_UNKNOWN = (-1), /* not known (before driver set) */ GR_VGA, /* VGA adapter */ GR_EGA, /* EGA adapter */ GR_HERC, /* Hercules mono adapter */ GR_8514A, /* 8514A or compatible */ GR_S3, /* S3 graphics accelerator */ GR_XWIN, /* X11 driver */ GR_MEM /* memory only driver */ } GrVideoAdapter; Note that the 'VESA' driver return 'GR_VGA' here. Graphics contexts The library supports a set of drawing regions called 'contexts' (the 'GrContext' structure). These can be in video memory or in system memory. Contexts in system memory always have the same memory organization as the video memory. When 'GrSetMode' is called, a default context is created which maps to the whole graphics screen. Contexts are described by the 'GrContext' data structure: typedef struct _GR_context GrContext; struct _GR_context { struct _GR_frame gc_frame; /* frame buffer info */ struct _GR_context *gc_root; /* context which owns frame */ int gc_xmax; /* max X coord (width - 1) */ int gc_ymax; /* max Y coord (height - 1) */ int gc_xoffset; /* X offset from root's base */ int gc_yoffset; /* Y offset from root's base */ int gc_xcliplo; /* low X clipping limit */ int gc_ycliplo; /* low Y clipping limit */ int gc_xcliphi; /* high X clipping limit */ int gc_ycliphi; /* high Y clipping limit */ int gc_usrxbase; /* user window min X coordinate */ int gc_usrybase; /* user window min Y coordinate */ int gc_usrwidth; /* user window width */ int gc_usrheight; /* user window height */ # define gc_baseaddr gc_frame.gf_baseaddr # define gc_selector gc_frame.gf_selector # define gc_onscreen gc_frame.gf_onscreen # define gc_memflags gc_frame.gf_memflags # define gc_lineoffset gc_frame.gf_lineoffset # define gc_driver gc_frame.gf_driver }; The following four functions return information about the layout of and memory occupied by a graphics context of size 'width' by 'height' in the current graphics mode (as set up by 'GrSetMode'): int GrLineOffset(int width); int GrNumPlanes(void); long GrPlaneSize(int w,int h); long GrContextSize(int w,int h); 'GrLineOffset' always returns the offset between successive pixel rows of the context in bytes. 'GrNumPlanes' returns the number of bitmap planes in the current graphics mode. 'GrContextSize' calculates the total amount of memory needed by a context, while 'GrPlaneSize' calculates the size of a bitplane in the context. The function: GrContext *GrCreateContext(int w,int h,char far *memory[4],GrContext *where); can be used to create a new context in system memory. The NULL pointer is also accepted as the value of the 'memory' and 'where' arguments, in this case the library allocates the necessary amount of memory internally. It is a general convention in the library that functions returning pointers to any LIBGRX specific data structure have a last argument (most of the time named 'where' in the prototypes) which can be used to pass the address of the data structure which should be filled with the result. If this 'where' pointer has the value of NULL, then the library allocates space for the data structure internally. The 'memory' argument is really a 4 pointer array, each pointer must point to space to handle 'GrPlaneSize(w,h)' bytes, really only 'GrNumPlanes()' pointers must be malloced, the rest can be NULL. Nevertheless the normal use (see below) is 'gc = GrCreateContext(w,h,NULL,NULL)', so yo don't need to care about. The function: GrContext *GrCreateSubContext(int x1,int y1,int x2,int y2, const GrContext *parent,GrContext *where); creates a new sub-context which maps to a part of an existing context. The coordinate arguments ('x1' through 'y2') are interpreted relative to the parent context's limits. Pixel addressing is zero-based even in sub-contexts, i.e. the address of the top left pixel is (0,0) even in a sub-context which has been mapped onto the interior of its parent context. Sub-contexts can be resized, but not their parents (i.e. anything returned by 'GrCreateContext' or set up by 'GrSetMode' cannot be resized -- because this could lead to irrecoverable "loss" of drawing memory. The following function can be used for this purpose: void GrResizeSubContext(GrContext *context,int x1,int y1,int x2,int y2); The current context structure is stored in a static location in the library. (For efficiency reasons -- it is used quite frequently, and this way no pointer dereferencing is necessary.) The context stores all relevant information about the video organization, coordinate limits, etc... The current context can be set with the: void GrSetContext(const GrContext *context); function. This function will reset the current context to the full graphics screen if it is passed the NULL pointer as argument. The value of the current context can be saved into a 'GrContext' structure pointed to by 'where' using: GrContext *GrSaveContext(GrContext *where); (Again, if 'where' is NULL, the library allocates the space.) The next two functions: const GrContext *GrCurrentContext(void); const GrContext *GrScreenContext(void); return the current context and the screen context respectively. Contexts can be destroyed with: void GrDestroyContext(GrContext *context); This function will free the memory occupied by the context only if it was allocated originally by the library. The next three functions set up and query the clipping limits associated with the current context: void GrSetClipBox(int x1,int y1,int x2,int y2); void GrGetClipBox(int *x1p,int *y1p,int *x2p,int *y2p); void GrResetClipBox(void); 'GrResetClipBox' sets the clipping limits to the limits of context. These are the limits set up initially when a context is created. There are three similar functions to sets/gets the clipping limits of any context: void GrSetClipBoxC(GrContext *c,int x1,int y1,int x2,int y2); void GrGetClipBoxC(const GrContext *c,int *x1p,int *y1p,int *x2p,int *y2p); void GrResetClipBoxC(GrContext *c); The limits of the current context can be obtained using the following functions: int GrMaxX(void); int GrMaxY(void); int GrSizeX(void); int GrSizeY(void); The 'Max' functions return the biggest valid coordinate, while the 'Size' functions return a value one higher. The limits of the graphics screen (regardless of the current context) can be obtained with: int GrScreenX(void); int GrScreenY(void); If you had set a virtual screen (using a custom graphics mode), the limits of the virtual screen can be fetched with: int GrVirtualX(void); int GrVirtualY(void); The routine: int GrScreenIsVirtual(void); returns non zero if a virtual screen is set. The rectangle showed in the real screen can be set with: int GrSetViewport(int xpos,int ypos); and the current viewport position can be obtained by: int GrViewportX(void); int GrViewportY(void); Context use Here is a example of normal context use: GrContext *grc; if( (grc = GrCreateContext( w,h,NULL,NULL )) == NULL ){ ...process the error } else{ GrSetContext( grc ); ...do some drawing ...and probably bitblt to the screen context GrSetContext( NULL ); /* the screen context! */ GrDestroyContext( grc ); } But if you have a GrContext variable (not a pointer) you want to use (probably because is static to some routines) you can do: static GrContext grc; /* not a pointer!! */ if( GrCreateContext( w,h,NULL,&grc )) == NULL ){ ...process the error } else{ GrSetContext( &grc ); ...do some drawing ...and probably bitblt to the screen context GrSetContext( NULL ); /* the screen context! */ GrDestroyContext( &grc ); } Note that GrDestoryContext know if grc was automatically malloced or no!! Only if you don't want GrCreateContext use malloc at all, you must allocate the memory buffers and pass it to GrCreateContext. Using GrCreateSubContext is the same, except it didn't need the buffer, because it uses the parent buffer. [View Less]

2 2

GRX user's manual 5
by Mariano Alvarez Fernandez 26 Aug '00

26 Aug '00

Hi, about fonts and user cooridnates, the end is coming :-) * Text drawing The library supports loadable fonts. When in memory they are bit-mapped (i.e. not scalable!) fonts. A driver design allow GRX to load different font formats, the last GRX release come with drivers to load the GRX own font format and the BGI Borland format for all platforms supported, the X11 version can load X11 fonts too. The GRX distribution come with a font collection in the GRX own format. Some of these fonts … [View More]were converted from VGA fonts. These fonts have all 256 characters from the PC-437 codepage. Some additional fonts were converted from fonts in the MIT X11 distribution. Most of these are ISO-8859-1 coded. Fonts also have family names. The following font families are included: Font file name Family Description: pc<W>x<H>[t].fnt pc VGA font, fixed xm<W>x<H>[b][i].fnt X_misc X11, fixed, miscellaneous group char<H>[b][i].fnt char X11, proportional, charter family cour<H>[b][i].fnt cour X11, fixed, courier helve<H>[b][i].fnt helve X11, proportional, helvetica lucb<H>[b][i].fnt lucb X11, proportional, lucida bright lucs<H>[b][i].fnt lucs X11, proportional, lucida sans serif luct<H>[b][i].fnt luct X11, fixed, lucida typewriter ncen<H>[b][i].fnt ncen X11, proportional, new century schoolbook symb<H>.fnt symbol X11, proportional, greek letters, symbols tms<H>[b][i].fnt times X11, proportional, times In the font names <W> means the font width, <H> the font height. Many font families have bold and/or italic variants. The files containing these fonts contain a 'b' and/or 'i' character in their name just before the extension. Additionally, the strings "_bold" and/or "_ital" are appended to the font family names. Some of the pc VGA fonts come in thin formats also, these are denoted by a 't' in their file names and the string "_thin" in their family names. The 'GrFont' structure hold a font in memory. A number of 'pc' fonts are built-in to the library and don't need to be loaded: extern GrFont GrFont_PC6x8; extern GrFont GrFont_PC8x8; extern GrFont GrFont_PC8x14; extern GrFont GrFont_PC8x16; Other fonts must be loaded with the 'GrLoadFont' function. If the font file name starts with any path separator character or character sequence ('<drive letter>:', '/' or '\') then it is loaded from the specified directory, otherwise the library try load the font first from the current directory and next from the default font path. The font path can be set up with the 'GrSetFontPath' function. If the font path is not set then the value of the 'GRXFONT' environment variable is used as the font path. If 'GrLoadFont' is called again with the name of an already loaded font then it will return a pointer to the result of the first loading. Font loading routines return NULL if the font was not found. When not needed any more, fonts can be unloaded (i.e. the storage occupied by them freed) by calling 'GrUnloadFont'. The prototype declarations for these functions: GrFont *GrLoadFont(char *name); void GrUnloadFont(GrFont *font); void GrSetFontPath(char *path_list); Using these functions: GrFont *GrLoadConvertedFont(char *name,int cvt,int w,int h, int minch,int maxch); GrFont *GrBuildConvertedFont(GrFont *from,int cvt,int w,int h, int minch,int maxch); a new font can be generated from a file font or a font in memory, the 'cvt' argument direct the conversion or-ing the desired operations from these defines: /* * Font conversion flags for 'GrLoadConvertedFont'. OR them as desired. */ #define GR_FONTCVT_NONE 0 /* no conversion */ #define GR_FONTCVT_SKIPCHARS 1 /* load only selected characters */ #define GR_FONTCVT_RESIZE 2 /* resize the font */ #define GR_FONTCVT_ITALICIZE 4 /* tilt font for "italic" look */ #define GR_FONTCVT_BOLDIFY 8 /* make a "bold"(er) font */ #define GR_FONTCVT_FIXIFY 16 /* convert prop. font to fixed wdt */ #define GR_FONTCVT_PROPORTION 32 /* convert fixed font to prop. wdt */ 'GR_FONTCVT_SKIPCHARS' needs 'minch' and 'maxch' arguments. 'GR_FONTCVT_RESIZE' needs 'w' and 'h' arguments. The function: void GrDumpFont(GrFont *f,char *CsymbolName,char *fileName); write a font to file like C code, so it can be linked with a user program. This simple function: void GrTextXY(int x,int y,char *text,GrColor fg,GrColor bg); draw text in the current context in the standard direction, using the 'GrDefaultFont' (mapped in the "grx20.h" file to the 'GrFont_PC8x14' font) with 'x', 'y' like the upper left corner and the foreground and background colors given (note that 'bg' equal to 'GrBlack() | GrAND' make the background transparent). For other functions the 'GrTextOption' structure specifies how to draw a character string: typedef struct _GR_textOption { /* text drawing option structure */ struct _GR_font *txo_font; /* font to be used */ union _GR_textColor txo_fgcolor; /* foreground color */ union _GR_textColor txo_bgcolor; /* background color */ char txo_chrtype; /* character type (see above) */ char txo_direct; /* direction (see above) */ char txo_xalign; /* X alignment (see above) */ char txo_yalign; /* Y alignment (see above) */ } GrTextOption; typedef union _GR_textColor { /* text color union */ GrColor v; /* color value for "direct" text */ GrColorTableP p; /* color table for attribute text */ } GrTextColor; The text can be rotated in increments of 90 degrees ('txo_direct'), alignments can be set in both directions ('txo_xalign' and 'txo_yalign'), and separate fore and background colors can be specified. The accepted text direction values: #define GR_TEXT_RIGHT 0 /* normal */ #define GR_TEXT_DOWN 1 /* downward */ #define GR_TEXT_LEFT 2 /* upside down, right to left */ #define GR_TEXT_UP 3 /* upward */ #define GR_TEXT_DEFAULT GR_TEXT_RIGHT The accepted horizontal and vertical alignment option values: #define GR_ALIGN_LEFT 0 /* X only */ #define GR_ALIGN_TOP 0 /* Y only */ #define GR_ALIGN_CENTER 1 /* X, Y */ #define GR_ALIGN_RIGHT 2 /* X only */ #define GR_ALIGN_BOTTOM 2 /* Y only */ #define GR_ALIGN_BASELINE 3 /* Y only */ #define GR_ALIGN_DEFAULT GR_ALIGN_LEFT Text strings can be of three different types: one character per byte (i.e. the usual C character string, this is the default), one character per 16-bit word (suitable for fonts with a large number of characters), and a PC-style character-attribute pair. In the last case the 'GrTextOption' structure must contain a pointer to a color table of size 16 (fg color bits in attrib) or 8 (bg color bits). (The color table format is explained in more detail in the previous section explaining the methods to build fill patterns.) The supported text types: #define GR_BYTE_TEXT 0 /* one byte per character */ #define GR_WORD_TEXT 1 /* two bytes per character */ #define GR_ATTR_TEXT 2 /* chr w/ PC style attribute byte */ The PC-style attribute text uses the same layout (first byte: character, second: attributes) and bitfields as the text mode screen on the PC. The only difference is that the 'blink' bit is not supported (it would be very time consuming -- the PC text mode does it with hardware support). This bit is used instead to control the underlined display of characters. For convenience the following attribute manipulation macros have been declared in "grx20.h": #define GR_BUILD_ATTR(fg,bg,ul) \ (((fg) & 15) | (((bg) & 7) << 4) | ((ul) ? 128 : 0)) #define GR_ATTR_FGCOLOR(attr) (((attr) ) & 15) #define GR_ATTR_BGCOLOR(attr) (((attr) >> 4) & 7) #define GR_ATTR_UNDERLINE(attr) (((attr) ) & 128) Text strings of the types 'GR_BYTE_TEXT' and 'GR_WORD_TEXT" can also be drawn underlined. This is controlled by OR-ing the constant 'GR_UNDERLINE_TEXT' to the foreground color value: #define GR_UNDERLINE_TEXT (GrXOR << 4) After the application initializes a text option structure with the desired values it can call one of the following two text drawing functions: void GrDrawChar(int chr,int x,int y,GrTextOption *opt); void GrDrawString(void *text,int length,int x,int y,GrTextOption *opt); NOTE: text drawing is fastest when it is drawn in the 'normal' direction, and the character does not have to be clipped. It this case the library can use the appropriate low-level video RAM access routine, while in any other case the text is drawn pixel-by-pixel by the higher-level code. There are too pattern filed versions: void GrPatternDrawChar(int chr,int x,int y,GrTextOption *opt,GrPattern *p); void GrPatternDrawString(void *text,int length,int x,int y,GrTextOption *opt, GrPattern *p); void GrPatternDrawStringExt(void *text,int length,int x,int y, GrTextOption *opt,GrPattern *p); The size of a font, a character or a text string can be obtained by calling one of the following functions. These functions also take into consideration the text direction specified in the text option structure passed to them. int GrFontCharPresent(GrFont *font,int chr); int GrFontCharWidth(GrFont *font,int chr); int GrFontCharHeight(GrFont *font,int chr); int GrFontCharBmpRowSize(GrFont *font,int chr); int GrFontCharBitmapSize(GrFont *font,int chr); int GrFontStringWidth(GrFont *font,void *text,int len,int type); int GrFontStringHeight(GrFont *font,void *text,int len,int type); int GrProportionalTextWidth(GrFont *font,void *text,int len,int type); int GrCharWidth(int chr,GrTextOption *opt); int GrCharHeight(int chr,GrTextOption *opt); void GrCharSize(int chr,GrTextOption *opt,int *w,int *h); int GrStringWidth(void *text,int length,GrTextOption *opt); int GrStringHeight(void *text,int length,GrTextOption *opt); void GrStringSize(void *text,int length,GrTextOption *opt,int *w,int *h); The 'GrTextRegion' structure and its associated functions can be used to implement a fast (as much as possible in graphics modes) rectangular text window using a fixed font. Clipping for such windows is done in character size increments instead of pixels (i.e. no partial characters are drawn). Only fixed fonts can be used in their natural size. 'GrDumpText' will cache the code of the drawn characters in the buffer pointed to by the 'backup' slot (if it is non-NULL) and will draw a character only if the previously drawn character in that grid element is different. This can speed up text scrolling significantly in graphics modes. The supported text types are the same as above. typedef struct { /* fixed font text window desc. */ struct _GR_font *txr_font; /* font to be used */ union _GR_textColor txr_fgcolor; /* foreground color */ union _GR_textColor txr_bgcolor; /* background color */ void *txr_buffer; /* pointer to text buffer */ void *txr_backup; /* optional backup buffer */ int txr_width; /* width of area in chars */ int txr_height; /* height of area in chars */ int txr_lineoffset; /* offset in buffer(s) between rows */ int txr_xpos; /* upper left corner X coordinate */ int txr_ypos; /* upper left corner Y coordinate */ char txr_chrtype; /* character type (see above) */ } GrTextRegion; void GrDumpChar(int chr,int col,int row,GrTextRegion *r); void GrDumpText(int col,int row,int wdt,int hgt,GrTextRegion *r); void GrDumpTextRegion(GrTextRegion *r); The 'GrDumpTextRegion' function outputs the whole text region, while 'GrDumpText' draws only a user-specified part of it. 'GrDumpChar' updates the character in the buffer at the specified location with the new character passed to it as argument and then draws the new character on the screen as well. With these functions you can simulate a text mode window, write chars directly to the 'txr_buffer' and call 'GrDumpTextRegion' when you want to update the window (or 'GrDumpText' if you know the area to update is small). * Drawing in user coordinates There is a second set of the graphics primitives which operates in user coordinates. Every context has a user to screen coordinate mapping associated with it. An application specifies the user window by calling the 'GrSetUserWindow' function. void GrSetUserWindow(int x1,int y1,int x2,int y2); A call to this function it in fact specifies the virtual coordinate limits which will be mapped onto the current context regardless of the size of the context. For example, the call: GrSetUserWindow(0,0,11999,8999); tells the library that the program will perform its drawing operations in a coordinate system X:0...11999 (width = 12000) and Y:0...8999 (height = 9000). This coordinate range will be mapped onto the total area of the current context. The virtual coordinate system can also be shifted. For example: GrSetUserWindow(5000,2000,16999,10999); The user coordinates can even be used to turn the usual left-handed coordinate system (0:0 corresponds to the upper left corner) to a right handed one (0:0 corresponds to the bottom left corner) by calling: GrSetUserWindow(0,8999,11999,0); The library also provides three utility functions for the query of the current user coordinate limits and for converting user coordinates to screen coordinates and vice versa. void GrGetUserWindow(int *x1,int *y1,int *x2,int *y2); void GrGetScreenCoord(int *x,int *y); void GrGetUserCoord(int *x,int *y); If an application wants to take advantage of the user to screen coordinate mapping it has to use the user coordinate version of the graphics primitives. These have exactly the same parameter passing conventions as their screen coordinate counterparts. NOTE: the user coordinate system is not initialized by the library! The application has to set up its coordinate mapping before calling any of the use coordinate drawing functions -- otherwise the program will almost certainly exit (in a quite ungraceful fashion) with a 'division by zero' error. The list of supported user coordinate drawing functions: void GrUsrPlot(int x,int y,GrColor c); void GrUsrLine(int x1,int y1,int x2,int y2,GrColor c); void GrUsrHLine(int x1,int x2,int y,GrColor c); void GrUsrVLine(int x,int y1,int y2,GrColor c); void GrUsrBox(int x1,int y1,int x2,int y2,GrColor c); void GrUsrFilledBox(int x1,int y1,int x2,int y2,GrColor c); void GrUsrFramedBox(int x1,int y1,int x2,int y2,int wdt,GrFBoxColors *c); void GrUsrCircle(int xc,int yc,int r,GrColor c); void GrUsrEllipse(int xc,int yc,int xa,int ya,GrColor c); void GrUsrCircleArc(int xc,int yc,int r,int start,int end, int style,GrColor c); void GrUsrEllipseArc(int xc,int yc,int xa,int ya,int start,int end, int style,GrColor c); void GrUsrFilledCircle(int xc,int yc,int r,GrColor c); void GrUsrFilledEllipse(int xc,int yc,int xa,int ya,GrColor c); void GrUsrFilledCircleArc(int xc,int yc,int r,int start,int end, int style,GrColor c); void GrUsrFilledEllipseArc(int xc,int yc,int xa,int ya,int start,int end, int style,GrColor c); void GrUsrPolyLine(int numpts,int points[][2],GrColor c); void GrUsrPolygon(int numpts,int points[][2],GrColor c); void GrUsrFilledConvexPolygon(int numpts,int points[][2],GrColor c); void GrUsrFilledPolygon(int numpts,int points[][2],GrColor c); void GrUsrFloodFill(int x, int y, GrColor border, GrColor c); GrColor GrUsrPixel(int x,int y); GrColor GrUsrPixelC(GrContext *c,int x,int y); void GrUsrCustomLine(int x1,int y1,int x2,int y2,GrLineOption *o); void GrUsrCustomBox(int x1,int y1,int x2,int y2,GrLineOption *o); void GrUsrCustomCircle(int xc,int yc,int r,GrLineOption *o); void GrUsrCustomEllipse(int xc,int yc,int xa,int ya,GrLineOption *o); void GrUsrCustomCircleArc(int xc,int yc,int r,int start,int end, int style,GrLineOption *o); void GrUsrCustomEllipseArc(int xc,int yc,int xa,int ya,int start,int end, int style,GrLineOption *o); void GrUsrCustomPolyLine(int numpts,int points[][2],GrLineOption *o); void GrUsrCustomPolygon(int numpts,int points[][2],GrLineOption *o); void GrUsrPatternedLine(int x1,int y1,int x2,int y2,GrLinePattern *lp); void GrUsrPatternedBox(int x1,int y1,int x2,int y2,GrLinePattern *lp); void GrUsrPatternedCircle(int xc,int yc,int r,GrLinePattern *lp); void GrUsrPatternedEllipse(int xc,int yc,int xa,int ya,GrLinePattern *lp); void GrUsrPatternedCircleArc(int xc,int yc,int r,int start,int end, int style,GrLinePattern *lp); void GrUsrPatternedEllipseArc(int xc,int yc,int xa,int ya,int start,int end, int style,GrLinePattern *lp); void GrUsrPatternedPolyLine(int numpts,int points[][2],GrLinePattern *lp); void GrUsrPatternedPolygon(int numpts,int points[][2],GrLinePattern *lp); void GrUsrPatternFilledPlot(int x,int y,GrPattern *p); void GrUsrPatternFilledLine(int x1,int y1,int x2,int y2,GrPattern *p); void GrUsrPatternFilledBox(int x1,int y1,int x2,int y2,GrPattern *p); void GrUsrPatternFilledCircle(int xc,int yc,int r,GrPattern *p); void GrUsrPatternFilledEllipse(int xc,int yc,int xa,int ya,GrPattern *p); void GrUsrPatternFilledCircleArc(int xc,int yc,int r,int start,int end,int style,GrPattern *p); void GrUsrPatternFilledEllipseArc(int xc,int yc,int xa,int ya,int start,int end,int style,GrPattern *p); void GrUsrPatternFilledConvexPolygon(int numpts,int points[][2],GrPattern *p); void GrUsrPatternFilledPolygon(int numpts,int points[][2],GrPattern *p); void GrUsrPatternFloodFill(int x, int y, GrColor border, GrPattern *p); void GrUsrDrawChar(int chr,int x,int y,GrTextOption *opt); void GrUsrDrawString(char *text,int length,int x,int y,GrTextOption *opt); void GrUsrTextXY(int x,int y,char *text,GrColor fg,GrColor bg); [View Less]

1 0

GRX user's manual 4
by Mariano Alvarez Fernandez 24 Aug '00

24 Aug '00

Another part * Pattern filled graphics primitives The library also supports a pattern filled version of the basic filled primitives described above. These functions have similar parameter passing conventions as the basic ones with one difference: instead of the color value a pointer to an union of type 'GrPattern' has to be passed to them. The 'GrPattern' union can contain either a bitmap or a pixmap fill pattern. The first integer slot in the union determines which type it is. Bitmap fill … [View More]patterns are rectangular arrays of bits, each set bit representing the foreground color of the fill operation, and each zero bit representing the background. Both the foreground and background colors can be combined with any of the supported logical operations. Bitmap fill patterns have one restriction: their width must be eight pixels. Pixmap fill patterns are very similar to contexts. The relevant structure declarations (from "grx20.h"): /* * 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!!! */ typedef struct _GR_bitmap { int bmp_ispixmap; /* type flag for pattern union */ int bmp_height; /* bitmap height */ char *bmp_data; /* pointer to the bit pattern */ GrColor bmp_fgcolor; /* foreground color for fill */ GrColor bmp_bgcolor; /* background color for fill */ int bmp_memflags; /* set if dynamically allocated */ } GrBitmap; /* * 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 { int pxp_ispixmap; /* type flag for pattern union */ int pxp_width; /* pixmap width (in pixels) */ int pxp_height; /* pixmap height (in pixels) */ GrColor pxp_oper; /* bitblt mode (SET, OR, XOR, AND, IMAGE) */ struct _GR_frame pxp_source; /* source context for fill */ } GrPixmap; /* * Fill pattern union -- can either be a bitmap or a pixmap */ typedef union _GR_pattern { int gp_ispixmap; /* nonzero for pixmaps */ GrBitmap gp_bitmap; /* fill bitmap */ GrPixmap gp_pixmap; /* fill pixmap */ } GrPattern; This define group (from "grx20.h") help to acces the 'GrPattern0 menbers: #define gp_bmp_data gp_bitmap.bmp_data #define gp_bmp_height gp_bitmap.bmp_height #define gp_bmp_fgcolor gp_bitmap.bmp_fgcolor #define gp_bmp_bgcolor gp_bitmap.bmp_bgcolor #define gp_pxp_width gp_pixmap.pxp_width #define gp_pxp_height gp_pixmap.pxp_height #define gp_pxp_oper gp_pixmap.pxp_oper #define gp_pxp_source gp_pixmap.pxp_source Bitmap patterns can be easily built from initialized character arrays and static structures by the C compiler, thus no special support is included in the library for creating them. The only action required from the application program might be changing the foreground and background colors as needed. Pixmap patterns are more difficult to build as they replicate the layout of the video memory which changes for different video modes. For this reason the library provides three functions to create pixmap patterns in a mode-independent way: GrPattern *GrBuildPixmap(char *pixels,int w,int h,GrColorTableP colors); GrPattern *GrBuildPixmapFromBits(char *bits,int w,int h, GrColor fgc,GrColor bgc); GrPattern *GrConvertToPixmap(GrContext *src); 'GrBuildPixmap' build a pixmap from a two dimensional ('w' by 'h') array of characters. The elements in this array are used as indices into the color table specified with the argument 'colors'. (This means that pixmaps created this way can use at most 256 colors.) The color table pointer: typedef GrColor *GrColorTableP; should point to an array of integers with the first element being the number of colors in the table and the color values themselves starting with the second element. NOTE: any color modifiers (GrXOR, GrOR, GrAND) OR-ed to the elements of the color table are ignored. The 'GrBuildPixmapFromBits' function builds a pixmap fill pattern from bitmap data. It is useful if the width of the bitmap pattern is not eight as such bitmap patterns can not be used to build a 'GrBitmap' structure. The 'GrConvertToPixmap' function converts a graphics context to a pixmap fill pattern. It is useful when the pattern can be created with graphics drawing operations. NOTE: the pixmap pattern and the original context share the drawing RAM, thus if the context is redrawn the fill pattern changes as well. Fill patterns which were built by library routines can be destroyed when no longer needed (i.e. the space occupied by them can be freed) by calling: void GrDestroyPattern(GrPattern *p); NOTE: when pixmap fill patterns converted from contexts are destroyed, the drawing RAM is not freed. It is freed when the original context is destroyed. Fill patterns built by the application have to be destroyed by the application as well (if this is needed). The list of supported pattern filled graphics primitives is shown below. These functions are very similar to their solid filled counterparts, only their last argument is different: void GrPatternFilledPlot(int x,int y,GrPattern *p); void GrPatternFilledLine(int x1,int y1,int x2,int y2,GrPattern *p); void GrPatternFilledBox(int x1,int y1,int x2,int y2,GrPattern *p); void GrPatternFilledCircle(int xc,int yc,int r,GrPattern *p); void GrPatternFilledEllipse(int xc,int yc,int xa,int ya,GrPattern *p); void GrPatternFilledCircleArc(int xc,int yc,int r,int start,int end, int style,GrPattern *p); void GrPatternFilledEllipseArc(int xc,int yc,int xa,int ya,int start,int end, int style,GrPattern *p); void GrPatternFilledConvexPolygon(int numpts,int points[][2],GrPattern *p); void GrPatternFilledPolygon(int numpts,int points[][2],GrPattern *p); void GrPatternFloodFill(int x, int y, GrColor border, GrPattern *p); Strictly speaking the plot and line functions in the above group are not filled, but they have been included here for convenience. * Patterned line drawing The custom line drawing functions introduced above also have a version when the drawn sections can be filled with a (pixmap or bitmap) fill pattern. To achieve this these functions must be passed both a custom line drawing option ('GrLineOption' structure) and a fill pattern ('GrPattern' union). These two have been combined into the 'GrLinePattern' structure: typedef struct { GrPattern *lnp_pattern; /* fill pattern */ GrLineOption *lnp_option; /* width + dash pattern */ } GrLinePattern; All patterned line drawing functions take a pointer to this structure as their last argument. The list of available functions: void GrPatternedLine(int x1,int y1,int x2,int y2,GrLinePattern *lp); void GrPatternedBox(int x1,int y1,int x2,int y2,GrLinePattern *lp); void GrPatternedCircle(int xc,int yc,int r,GrLinePattern *lp); void GrPatternedEllipse(int xc,int yc,int xa,int ya,GrLinePattern *lp); void GrPatternedCircleArc(int xc,int yc,int r,int start,int end, int style,GrLinePattern *lp); void GrPatternedEllipseArc(int xc,int yc,int xa,int ya,int start,int end, int style,GrLinePattern *lp); void GrPatternedPolyLine(int numpts,int points[][2],GrLinePattern *lp); void GrPatternedPolygon(int numpts,int points[][2],GrLinePattern *lp); [View Less]

1 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

2000

1999

1998

1997

1996

1995

1994

Grx August 2000