| #include "grobjs.h" |
| #include "grdevice.h" |
| #include <stdlib.h> |
| #include <string.h> |
| |
| grDeviceChain gr_device_chain[ GR_MAX_DEVICES ]; |
| int gr_num_devices = 0; |
| |
| static |
| grDevice* find_device( const char* device_name ) |
| { |
| int index = 0; |
| |
| if (device_name) |
| { |
| for ( index = gr_num_devices-1; index > 0; index-- ) |
| if ( strcmp( device_name, gr_device_chain[index].name ) == 0 ) |
| break; |
| } |
| |
| if ( index < 0 || gr_num_devices <= 0 || !gr_device_chain[index].device ) |
| { |
| grError = gr_err_invalid_device; |
| return 0; |
| } |
| |
| return gr_device_chain[index].device; |
| } |
| |
| |
| |
| /********************************************************************** |
| * |
| * <Function> |
| * grGetDeviceModes |
| * |
| * <Description> |
| * queries the available pixel modes for a device. |
| * |
| * <Input> |
| * device_name :: name of device to be used. 0 for the default |
| * device. For a list of available devices, see |
| * grInitDevices. |
| * |
| * <Output> |
| * num_modes :: number of available modes. 0 in case of error, |
| * which really is an invalid device name. |
| * |
| * pixel_modes :: array of available pixel modes for this device |
| * this table is internal to the device and should |
| * not be freed by client applications. |
| * |
| * <Return> |
| * error code. 0 means success. invalid device name otherwise |
| * |
| * <Note> |
| * All drivers are _required_ to support at least the following |
| * pixel formats : |
| * |
| * - gr_pixel_mode_mono : i.e. monochrome bitmaps |
| * - gr_pixel_mode_gray : with any number of gray levels between |
| * 2 and 256. |
| * |
| * the pixel modes do not provide the number of grays in the case |
| * of "gray" devices. You should try to create a surface with the |
| * maximal number (256, that is) and see the value returned in |
| * the bitmap descriptor. |
| * |
| **********************************************************************/ |
| |
| extern void grGetDeviceModes( const char* device_name, |
| int *num_modes, |
| grPixelMode* *pixel_modes ) |
| { |
| grDevice* device; |
| |
| *num_modes = 0; |
| *pixel_modes = 0; |
| |
| device = find_device( device_name ); |
| if (device) |
| { |
| *num_modes = device->num_pixel_modes; |
| *pixel_modes = device->pixel_modes; |
| } |
| } |
| |
| |
| /********************************************************************** |
| * |
| * <Function> |
| * grNewSurface |
| * |
| * <Description> |
| * creates a new device-specific surface. A surface is either |
| * a window or a screen, depending on the device. |
| * |
| * <Input> |
| * device :: name of the device to use. A value of NULL means |
| * the default device (which depends on the system). |
| * for a list of available devices, see grInitDevices. |
| * |
| * <InOut> |
| * bitmap :: handle to a bitmap descriptor containing the |
| * requested pixel mode, number of grays and dimensions |
| * for the surface. the bitmap's 'pitch' and 'buffer' |
| * fields are ignored on input. |
| * |
| * On output, the bitmap describes the surface's image |
| * completely. It is possible to write directly in it |
| * with grBlitGlyphToBitmap, even though the use of |
| * grBlitGlyphToSurface is recommended. |
| * |
| * <Return> |
| * handle to the corresponding surface object. 0 in case of error |
| * |
| * <Note> |
| * All drivers are _required_ to support at least the following |
| * pixel formats : |
| * |
| * - gr_pixel_mode_mono : i.e. monochrome bitmaps |
| * - gr_pixel_mode_gray : with any number of gray levels between |
| * 2 and 256. |
| * |
| * This function might change the bitmap descriptor's fields. For |
| * example, when displaying a full-screen surface, the bitmap's |
| * dimensions will be set to those of the screen (e.g. 640x480 |
| * or 800x600); also, the bitmap's 'buffer' field might point to |
| * the Video Ram depending on the mode requested.. |
| * |
| * The surface contains a copy of the returned bitmap descriptor, |
| * you can thus discard the 'bitmap' parameter after the call. |
| * |
| **********************************************************************/ |
| |
| extern grSurface* grNewSurface( const char* device_name, |
| grBitmap* bitmap ) |
| { |
| grDevice* device; |
| grSurface* surface; |
| |
| /* Now find the device */ |
| device = find_device( device_name ); |
| if (!device) return 0; |
| |
| surface = (grSurface*)grAlloc( device->surface_objsize ); |
| if (!surface) return 0; |
| |
| if ( !device->init_surface( surface, bitmap ) ) |
| { |
| grFree( surface ); |
| surface = 0; |
| } |
| return surface; |
| } |
| |
| |
| /********************************************************************** |
| * |
| * <Function> |
| * grRefreshRectangle |
| * |
| * <Description> |
| * this function is used to indicate that a given surface rectangle |
| * was modified and thus needs re-painting. It really is useful for |
| * windowed or gray surfaces. |
| * |
| * <Input> |
| * surface :: handle to target surface |
| * x :: x coordinate of the top-left corner of the rectangle |
| * y :: y coordinate of the top-left corner of the rectangle |
| * width :: rectangle width in pixels |
| * height :: rectangle height in pixels |
| * |
| **********************************************************************/ |
| |
| extern void grRefreshRectangle( grSurface* surface, |
| grPos x, |
| grPos y, |
| grPos width, |
| grPos height ) |
| { |
| if (surface->refresh_rect) |
| surface->refresh_rect( surface, x, y, width, height ); |
| } |
| |
| |
| |
| /********************************************************************** |
| * |
| * <Function> |
| * grWriteSurfaceChar |
| * |
| * <Description> |
| * This function is equivalent to calling grWriteCellChar on the |
| * surface's bitmap, then invoking grRefreshRectangle. |
| * |
| * The graphics sub-system contains an internal Latin1 8x8 font |
| * which can be used to display simple strings of text without |
| * using FreeType. |
| * |
| * This function writes a single 8x8 character on the target bitmap. |
| * |
| * <Input> |
| * target :: handle to target surface |
| * x :: x pixel position of character cell's top left corner |
| * y :: y pixel position of character cell's top left corner |
| * charcode :: Latin-1 character code |
| * color :: color to be used to draw the character |
| * |
| **********************************************************************/ |
| |
| extern |
| void grWriteSurfaceChar( grSurface* target, |
| int x, |
| int y, |
| int charcode, |
| grColor color ) |
| { |
| grWriteCellChar( &target->bitmap, x, y, charcode, color ); |
| if (target->refresh_rect) |
| target->refresh_rect( target, x, y, 8, 8 ); |
| } |
| |
| |
| /********************************************************************** |
| * |
| * <Function> |
| * grWriteSurfaceString |
| * |
| * <Description> |
| * This function is equivalent to calling grWriteCellString on the |
| * surface's bitmap, then invoking grRefreshRectangle. |
| * |
| * The graphics sub-system contains an internal Latin1 8x8 font |
| * which can be used to display simple strings of text without |
| * using FreeType. |
| * |
| * This function writes a string with the internal font |
| * |
| * <Input> |
| * target :: handle to target bitmap |
| * x :: x pixel position of string's top left corner |
| * y :: y pixel position of string's top left corner |
| * string :: Latin-1 text string |
| * color :: color to be used to draw the character |
| * |
| **********************************************************************/ |
| |
| extern |
| void grWriteSurfaceString( grSurface* target, |
| int x, |
| int y, |
| const char* string, |
| grColor color ) |
| { |
| int len; |
| |
| len = strlen(string); |
| grWriteCellString( &target->bitmap, x, y, string, color ); |
| if (target->refresh_rect) |
| target->refresh_rect( target, x, y, 8*len, 8 ); |
| } |
| |
| |
| /********************************************************************** |
| * |
| * <Function> |
| * grRefreshSurface |
| * |
| * <Description> |
| * a variation of grRefreshRectangle which repaints the whole surface |
| * to the screen. |
| * |
| * <Input> |
| * surface :: handle to target surface |
| * |
| **********************************************************************/ |
| |
| extern void grRefreshSurface( grSurface* surface ) |
| { |
| if (surface->refresh_rect) |
| surface->refresh_rect( surface, 0, 0, |
| surface->bitmap.width, |
| surface->bitmap.rows ); |
| } |
| |
| |
| |
| /********************************************************************** |
| * |
| * <Function> |
| * grSetTitle |
| * |
| * <Description> |
| * set the window title of a given windowed surface. |
| * |
| * <Input> |
| * surface :: handle to target surface |
| * title_string :: the new title |
| * |
| **********************************************************************/ |
| |
| extern void grSetTitle( grSurface* surface, |
| const char* title_string ) |
| { |
| if (surface->set_title) |
| surface->set_title( surface, title_string ); |
| } |
| |
| |
| |
| |
| /********************************************************************** |
| * |
| * <Function> |
| * grListenSurface |
| * |
| * <Description> |
| * listen the events for a given surface |
| * |
| * <Input> |
| * surface :: handle to target surface |
| * event_mask :: the event mask (mode) |
| * |
| * <Output> |
| * event :: the returned event |
| * |
| * <Note> |
| * XXX : For now, only keypresses are supported. |
| * |
| **********************************************************************/ |
| |
| extern |
| int grListenSurface( grSurface* surface, |
| int event_mask, |
| grEvent *event ) |
| { |
| return surface->listen_event( surface, event_mask, event ); |
| } |
| |
| |
| #if 0 |
| static |
| void gr_done_surface( grSurface* surface ) |
| { |
| if (surface) |
| { |
| /* first of all, call the device-specific destructor */ |
| surface->done(surface); |
| |
| /* then remove the bitmap if we're owner */ |
| if (surface->owner) |
| grFree( surface->bitmap.buffer ); |
| |
| surface->owner = 0; |
| surface->bitmap.buffer = 0; |
| grFree( surface ); |
| } |
| } |
| #endif |
| |
