/*************************************************************************** gfx_operations Copyright (C) 2000 Christoph Reichenbach This program may be modified and copied freely according to the terms of the GNU general public license (GPL), as long as the above copyright notice and the licensing information contained herein are preserved. Please refer to www.gnu.org for licensing details. This work is provided AS IS, without warranty of any kind, expressed or implied, including but not limited to the warranties of merchantibility, noninfringement, and fitness for a specific purpose. The author will not be held liable for any damage caused by this work or derivatives of it. By using this source code, you agree to the licensing terms as stated above. Please contact the maintainer for bug reports or inquiries. Current Maintainer: Christoph Reichenbach (CR) ***************************************************************************/ /* Graphical operations, called from the widget state manager */ #include "sci/include/sci_memory.h" #include "sci/include/gfx_operations.h" #include #define PRECISE_PRIORITY_MAP /* Duplicate all operations on the local priority map as appropriate */ #undef GFXW_DEBUG_DIRTY /* Enable to debug stuff relevant for dirty rects ** in widget management */ #ifdef GFXW_DEBUG_DIRTY # define DDIRTY fprintf(stderr, "%s:%5d| ", __FILE__, __LINE__); fprintf #else # define DDIRTY if (0) fprintf #endif /* Default color maps */ #define DEFAULT_COLORS_NR 16 gfx_pixmap_color_t default_colors[DEFAULT_COLORS_NR] = {{GFX_COLOR_SYSTEM, 0x00, 0x00, 0x00}, {GFX_COLOR_SYSTEM, 0x00, 0x00, 0xaa}, {GFX_COLOR_SYSTEM, 0x00, 0xaa, 0x00}, {GFX_COLOR_SYSTEM, 0x00, 0xaa, 0xaa}, {GFX_COLOR_SYSTEM, 0xaa, 0x00, 0x00}, {GFX_COLOR_SYSTEM, 0xaa, 0x00, 0xaa}, {GFX_COLOR_SYSTEM, 0xaa, 0x55, 0x00}, {GFX_COLOR_SYSTEM, 0xaa, 0xaa, 0xaa}, {GFX_COLOR_SYSTEM, 0x55, 0x55, 0x55}, {GFX_COLOR_SYSTEM, 0x55, 0x55, 0xff}, {GFX_COLOR_SYSTEM, 0x55, 0xff, 0x55}, {GFX_COLOR_SYSTEM, 0x55, 0xff, 0xff}, {GFX_COLOR_SYSTEM, 0xff, 0x55, 0x55}, {GFX_COLOR_SYSTEM, 0xff, 0x55, 0xff}, {GFX_COLOR_SYSTEM, 0xff, 0xff, 0x55}, {GFX_COLOR_SYSTEM, 0xff, 0xff, 0xff}}; /* "Normal" EGA */ #define POINTER_VISIBLE_BUT_CLIPPED 2 /* Performs basic checks that apply to most functions */ #define BASIC_CHECKS(error_retval) \ if (!state) { \ GFXERROR("Null state!\n"); \ return error_retval; \ } \ if (!state->driver) { \ GFXERROR("GFX driver invalid!\n"); \ return error_retval; \ } /* How to determine whether colors have to be allocated */ #define PALETTE_MODE state->driver->mode->palette #define DRAW_POINTER { int __x = _gfxop_draw_pointer(state); if (__x) { GFXERROR("Drawing the mouse pointer failed!\n"); return __x;} } #define REMOVE_POINTER { int __x = _gfxop_remove_pointer(state); if (__x) { GFXERROR("Removing the mouse pointer failed!\n"); return __x;} } /* #define GFXOP_DEBUG_DIRTY */ /* Internal operations */ static void _gfxop_scale_rect(rect_t *rect, gfx_mode_t *mode) { int xfact = mode->xfact; int yfact = mode->yfact; rect->x *= xfact; rect->y *= yfact; rect->xl *= xfact; rect->yl *= yfact; } static void _gfxop_scale_point(point_t *point, gfx_mode_t *mode) { int xfact = mode->xfact; int yfact = mode->yfact; point->x *= xfact; point->y *= yfact; } static void _gfxop_alloc_colors(gfx_state_t *state, gfx_pixmap_color_t *colors, int colors_nr) { int i; if (!PALETTE_MODE) return; for (i = 0; i < colors_nr; i++) gfx_alloc_color(state->driver->mode->palette, colors + i); } #if 0 // Unreferenced - removed static void _gfxop_free_colors(gfx_state_t *state, gfx_pixmap_color_t *colors, int colors_nr) { int i; if (!PALETTE_MODE) return; for (i = 0; i < colors_nr; i++) gfx_free_color(state->driver->mode->palette, colors + i); } #endif int _gfxop_clip(rect_t *rect, rect_t clipzone) /* Returns 1 if nothing is left */ { #if 0 printf ("Clipping (%d, %d) size (%d, %d) by (%d,%d)(%d,%d)\n", rect->x, rect->y, rect->xl, rect->yl, clipzone.x, clipzone.y, clipzone.xl, clipzone.yl); #endif if (rect->x < clipzone.x) { rect->xl -= (clipzone.x - rect->x); rect->x = clipzone.x; } if (rect->y < clipzone.y) { rect->yl -= (clipzone.y - rect->y); rect->y = clipzone.y; } if (rect->x + rect->xl > clipzone.x + clipzone.xl) rect->xl = (clipzone.x + clipzone.xl) - rect->x; if (rect->y + rect->yl > clipzone.y + clipzone.yl) rect->yl = (clipzone.y + clipzone.yl) - rect->y; if (rect->xl < 0) rect->xl = 0; if (rect->yl < 0) rect->yl = 0; #if 0 printf (" => (%d, %d) size (%d, %d)\n", rect->x, rect->y, rect->xl, rect->yl); #endif return (rect->xl <= 0 || rect->yl <= 0); } static int _gfxop_grab_pixmap(gfx_state_t *state, gfx_pixmap_t **pxmp, int x, int y, int xl, int yl, int priority, rect_t *zone) /* Returns 1 if the resulting data size was zero, GFX_OK or an error code otherwise */ { int xfact = state->driver->mode->xfact; int yfact = state->driver->mode->yfact; int unscaled_xl = (xl + xfact - 1) / xfact; int unscaled_yl = (yl + yfact - 1) / yfact; *zone = gfx_rect(x, y, xl, yl); if (_gfxop_clip(zone, gfx_rect(0, 0, 320 * state->driver->mode->xfact, 200 * state->driver->mode->yfact))) return GFX_ERROR; if (!*pxmp) *pxmp = gfx_new_pixmap(unscaled_xl, unscaled_yl, GFX_RESID_NONE, 0, 0); else if (xl * yl > (*pxmp)->xl * (*pxmp)->yl) { gfx_pixmap_free_data(*pxmp); (*pxmp)->data = NULL; } if (!(*pxmp)->data) { (*pxmp)->index_xl = unscaled_xl + 1; (*pxmp)->index_yl = unscaled_yl + 1; gfx_pixmap_alloc_data(*pxmp, state->driver->mode); } return state->driver->grab_pixmap(state->driver, *zone, *pxmp, priority? GFX_MASK_PRIORITY : GFX_MASK_VISUAL); } #define DRAW_LOOP(condition) \ { \ rect_t drawrect = gfx_rect(pos.x, pos.y, pxm->index_xl, pxm->index_yl); \ int offset, base_offset; \ int read_offset, base_read_offset; \ int x,y; \ \ if (!pxm->index_data) { \ GFXERROR("Attempt to draw control color %d on pixmap %d/%d/%d without index data!\n", \ color, pxm->ID, pxm->loop, pxm->cel); \ return; \ } \ \ if (_gfxop_clip(&drawrect, gfx_rect(0, 0, 320, 200))) \ return; \ \ offset = base_offset = drawrect.x + drawrect.y * 320; \ read_offset = base_read_offset = (drawrect.x - pos.x) + ((drawrect.y - pos.y) * pxm->index_xl); \ \ for (y = 0; y < drawrect.yl; y++) { \ for (x = 0; x < drawrect.xl; x++) \ if (pxm->index_data[read_offset++] != pxm->color_key) { \ if (condition) \ map->index_data[offset++] = color; \ else \ ++offset; \ } else ++offset; \ \ offset = base_offset += 320; \ read_offset = base_read_offset += pxm->index_xl; \ } \ } static void _gfxop_draw_control(gfx_pixmap_t *map, gfx_pixmap_t *pxm, int color, point_t pos) DRAW_LOOP(1) /* Always draw */ #ifdef PRECISE_PRIORITY_MAP static void _gfxop_draw_priority(gfx_pixmap_t *map, gfx_pixmap_t *pxm, int color, point_t pos) DRAW_LOOP(map->index_data[offset] < color) /* Draw only lower priority */ #endif #undef DRAW_LOOP static int _gfxop_install_pixmap(gfx_driver_t *driver, gfx_pixmap_t *pxm) { int error; if (driver->capabilities & GFX_CAPABILITY_PIXMAP_REGISTRY && !(pxm->flags & GFX_PIXMAP_FLAG_INSTALLED)) { error = driver->register_pixmap(driver, pxm); if (error) { GFXERROR("driver->register_pixmap() returned error!\n"); return error; } pxm->flags |= GFX_PIXMAP_FLAG_INSTALLED; } if (driver->mode->palette && (!(pxm->flags & GFX_PIXMAP_FLAG_PALETTE_SET))) { int i; int error; for (i = 0; i < pxm->colors_nr; i++) { if ((error = driver->set_palette(driver, pxm->colors[i].global_index, pxm->colors[i].r, pxm->colors[i].g, pxm->colors[i].b))) { GFXWARN("driver->set_palette(%d, %02x/%02x/%02x) failed!\n", pxm->colors[i].global_index, pxm->colors[i].r, pxm->colors[i].g, pxm->colors[i].b); if (error == GFX_FATAL) return GFX_FATAL; } } pxm->flags |= GFX_PIXMAP_FLAG_PALETTE_SET; } return GFX_OK; } static int _gfxop_draw_pixmap(gfx_driver_t *driver, gfx_pixmap_t *pxm, int priority, int control, rect_t src, rect_t dest, rect_t clip, int static_buf, gfx_pixmap_t *control_map, gfx_pixmap_t *priority_map) { int error; rect_t clipped_dest = gfx_rect(dest.x, dest.y, dest.xl, dest.yl); if (control >= 0 || priority >= 0) { point_t original_pos = gfx_point(dest.x / driver->mode->xfact, dest.y / driver->mode->yfact); if (control >= 0) _gfxop_draw_control(control_map, pxm, control, original_pos); #ifdef PRECISE_PRIORITY_MAP if (priority >= 0) _gfxop_draw_priority(priority_map, pxm, priority, original_pos); #endif } if (_gfxop_clip(&clipped_dest, clip)) return GFX_OK; src.x += clipped_dest.x - dest.x; src.y += clipped_dest.y - dest.y; src.xl = clipped_dest.xl; src.yl = clipped_dest.yl; error = _gfxop_install_pixmap(driver, pxm); if (error) return error; DDIRTY(stderr, "\\-> Drawing to actual %d %d %d %d\n", clipped_dest.x / driver->mode->xfact, clipped_dest.y / driver->mode->yfact, clipped_dest.xl / driver->mode->xfact, clipped_dest.yl / driver->mode->yfact); error = driver->draw_pixmap(driver, pxm, priority, src, clipped_dest, static_buf? GFX_BUFFER_STATIC : GFX_BUFFER_BACK); if (error) { GFXERROR("driver->draw_pixmap() returned error!\n"); return error; } return GFX_OK; } static int _gfxop_remove_pointer(gfx_state_t *state) { if (state->mouse_pointer_visible && !state->mouse_pointer_in_hw && state->mouse_pointer_bg) { int retval; if (state->mouse_pointer_visible == POINTER_VISIBLE_BUT_CLIPPED) { state->mouse_pointer_visible = 0; state->pointer_pos.x = state->driver->pointer_x / state->driver->mode->xfact; state->pointer_pos.y = state->driver->pointer_y / state->driver->mode->yfact; return GFX_OK; } state->mouse_pointer_visible = 0; retval = state->driver->draw_pixmap(state->driver, state->mouse_pointer_bg, GFX_NO_PRIORITY, gfx_rect(0, 0, state->mouse_pointer_bg->xl, state->mouse_pointer_bg->yl), state->pointer_bg_zone, GFX_BUFFER_BACK); state->pointer_pos.x = state->driver->pointer_x / state->driver->mode->xfact; state->pointer_pos.y = state->driver->pointer_y / state->driver->mode->yfact; return retval; } else { state->pointer_pos.x = state->driver->pointer_x / state->driver->mode->xfact; state->pointer_pos.y = state->driver->pointer_y / state->driver->mode->yfact; return GFX_OK; } } static int /* returns 1 if there are no pointer bounds, 0 otherwise */ _gfxop_get_pointer_bounds(gfx_state_t *state, rect_t *rect) { gfx_pixmap_t *ppxm = state->mouse_pointer; if (!ppxm) return 1; rect->x = state->driver->pointer_x - ppxm->xoffset * (state->driver->mode->xfact); rect->y = state->driver->pointer_y - ppxm->yoffset * (state->driver->mode->yfact); rect->xl = ppxm->xl; rect->yl = ppxm->yl; return (_gfxop_clip(rect, gfx_rect(0, 0, 320 * state->driver->mode->xfact, 200 * state->driver->mode->yfact))); } static int _gfxop_buffer_propagate_box(gfx_state_t *state, rect_t box, gfx_buffer_t buffer); static int _gfxop_draw_pointer(gfx_state_t *state) { if (state->mouse_pointer_visible || !state->mouse_pointer || state->mouse_pointer_in_hw) return GFX_OK; else { int retval; gfx_pixmap_t *ppxm = state->mouse_pointer; int xfact, yfact; int x = state->driver->pointer_x - ppxm->xoffset * (xfact = state->driver->mode->xfact); int y = state->driver->pointer_y - ppxm->yoffset * (yfact = state->driver->mode->yfact); int error; state->mouse_pointer_visible = 1; state->old_pointer_draw_pos.x = x; state->old_pointer_draw_pos.y = y; /* FIXME: we are leaking the mouse_pointer_bg, but freeing it causes weirdness in jones * we should reuse the buffer instead of malloc/free for better performance */ retval = _gfxop_grab_pixmap(state, &(state->mouse_pointer_bg), x, y, ppxm->xl, ppxm->yl, 0, &(state->pointer_bg_zone)); if (retval == GFX_ERROR) { state->pointer_bg_zone = gfx_rect(0, 0, 320, 200); state->mouse_pointer_visible = POINTER_VISIBLE_BUT_CLIPPED; return GFX_OK; } if (retval) return retval; error = _gfxop_draw_pixmap(state->driver, ppxm, -1, -1, gfx_rect(0, 0, ppxm->xl, ppxm->yl), gfx_rect(x, y, ppxm->xl, ppxm->yl), gfx_rect(0, 0, xfact * 320 , yfact * 200), 0, state->control_map, state->priority_map); if (error) return error; return GFX_OK; } } gfx_pixmap_t * _gfxr_get_cel(gfx_state_t *state, int nr, int *loop, int *cel, int palette) { gfxr_view_t *view = gfxr_get_view(state->resstate, nr, loop, cel, palette); gfxr_loop_t *indexed_loop; if (!view) return NULL; if (*loop >= view->loops_nr || *loop < 0) { GFXWARN("Attempt to get cel from loop %d/%d inside view %d\n", *loop, view->loops_nr, nr); return NULL; } indexed_loop = view->loops + *loop; if (*cel >= indexed_loop->cels_nr || *cel < 0) { GFXWARN("Attempt to get cel %d/%d from view %d/%d\n", *cel, indexed_loop->cels_nr, nr, *loop); return NULL; } return indexed_loop->cels[*cel]; /* Yes, view->cels uses a malloced pointer list. */ } /*** Dirty rectangle operations ***/ static inline int _gfxop_update_box(gfx_state_t *state, rect_t box) { int retval; _gfxop_scale_rect(&box, state->driver->mode); if ((retval = _gfxop_buffer_propagate_box(state, box, GFX_BUFFER_FRONT))) { GFXERROR("Error occured while propagating box (%d,%d,%d,%d) to front buffer\n", box.x, box.y, box.xl, box.yl); return retval; } return GFX_OK; } static struct _dirty_rect * _rect_create(rect_t box) { struct _dirty_rect *rect; rect = (struct _dirty_rect*)sci_malloc(sizeof(struct _dirty_rect)); rect->next = NULL; rect->rect = box; return rect; } gfx_dirty_rect_t * gfxdr_add_dirty(gfx_dirty_rect_t *base, rect_t box, int strategy) { if (box.xl < 0) { box.x += box.xl; box.xl = - box.xl; } if (box.yl < 0) { box.y += box.yl; box.yl = - box.yl; } #ifdef GFXOP_DEBUG_DIRTY fprintf(stderr, "Adding new dirty (%d %d %d %d)\n", GFX_PRINT_RECT(box)); #endif if (_gfxop_clip(&box, gfx_rect(0, 0, 320, 200))) return base; switch (strategy) { case GFXOP_DIRTY_FRAMES_ONE: if (base) base->rect = gfx_rects_merge(box, base->rect); else base = _rect_create(box); break; case GFXOP_DIRTY_FRAMES_CLUSTERS: { struct _dirty_rect **rectp = &(base); while (*rectp) { if (gfx_rects_overlap((*rectp)->rect, box)) { struct _dirty_rect *next = (*rectp)->next; box = gfx_rects_merge((*rectp)->rect, box); free(*rectp); *rectp = next; } else rectp = &((*rectp)->next); } *rectp = _rect_create(box); } break; default: GFXERROR("Attempt to use invalid dirty frame mode %d!\nPlease refer to gfx_options.h.", strategy); } return base; } static void _gfxop_add_dirty(gfx_state_t *state, rect_t box) { if (state->disable_dirty) return; state->dirty_rects = gfxdr_add_dirty(state->dirty_rects, box, state->options->dirty_frames); } static inline void _gfxop_add_dirty_x(gfx_state_t *state, rect_t box) /* Extends the box size by one before adding (used for lines) */ { if (box.xl < 0) box.xl--; else box.xl++; if (box.yl < 0) box.yl--; else box.yl++; _gfxop_add_dirty(state, box); } static int _gfxop_clear_dirty_rec(gfx_state_t *state, struct _dirty_rect *rect) { int retval; if (!rect) return GFX_OK; #ifdef GFXOP_DEBUG_DIRTY fprintf(stderr, "\tClearing dirty (%d %d %d %d)\n", GFX_PRINT_RECT(rect->rect)); #endif if (!state->fullscreen_override) retval = _gfxop_update_box(state, rect->rect); else retval = GFX_OK; retval |= _gfxop_clear_dirty_rec(state, rect->next); free(rect); return retval; } /*** Exported operations ***/ static void init_aux_pixmap(gfx_pixmap_t **pixmap) { *pixmap = gfx_pixmap_alloc_index_data(gfx_new_pixmap(320, 200, GFX_RESID_NONE, 0, 0)); (*pixmap)->flags |= GFX_PIXMAP_FLAG_EXTERNAL_PALETTE; (*pixmap)->colors_nr = DEFAULT_COLORS_NR; (*pixmap)->colors = default_colors; } static int _gfxop_init_common(gfx_state_t *state, gfx_options_t *options, void *misc_payload) { state->options = options; if (!((state->resstate = gfxr_new_resource_manager(state->version, state->options, state->driver, misc_payload)))) { GFXERROR("Failed to initialize resource manager!\n"); return GFX_FATAL; } if ((state->static_palette = gfxr_interpreter_get_static_palette(state->resstate, state->version, &(state->static_palette_entries), misc_payload))) _gfxop_alloc_colors(state, state->static_palette, state->static_palette_entries); state->visible_map = GFX_MASK_VISUAL; state->fullscreen_override = NULL; /* No magical override */ gfxop_set_clip_zone(state, gfx_rect(0, 0, 320, 200)); state->mouse_pointer = state->mouse_pointer_bg = NULL; state->mouse_pointer_visible = 0; init_aux_pixmap(&(state->control_map)); init_aux_pixmap(&(state->priority_map)); init_aux_pixmap(&(state->static_priority_map)); state->options = options; state->mouse_pointer_in_hw = 0; state->disable_dirty = 0; state->events = NULL; state->pic = state->pic_unscaled = NULL; state->pic_nr = -1; /* Set background pic number to an invalid value */ state->tag_mode = 0; state->dirty_rects = NULL; state->old_pointer_draw_pos.x = -1; state->old_pointer_draw_pos.y = -1; return GFX_OK; } int gfxop_init_default(gfx_state_t *state, gfx_options_t *options, void *misc_info) { BASIC_CHECKS(GFX_FATAL); if (state->driver->init(state->driver)) return GFX_FATAL; return _gfxop_init_common(state, options, misc_info); } int gfxop_init(gfx_state_t *state, int xfact, int yfact, gfx_color_mode_t bpp, gfx_options_t *options, void *misc_info) { int color_depth = bpp? bpp : 1; int initialized = 0; BASIC_CHECKS(GFX_FATAL); do { if (!state->driver->init_specific(state->driver, xfact, yfact, color_depth)) initialized = 1; else color_depth++; } while (!initialized && color_depth < 9 && !bpp); if (!initialized) return GFX_FATAL; return _gfxop_init_common(state, options, misc_info); } int gfxop_set_parameter(gfx_state_t *state, char *attribute, char *value) { BASIC_CHECKS(GFX_FATAL); return state->driver->set_parameter(state->driver, attribute, value); } int gfxop_exit(gfx_state_t *state) { BASIC_CHECKS(GFX_ERROR); gfxr_free_resource_manager(state->driver, state->resstate); if (state->control_map) { gfx_free_pixmap(state->driver, state->control_map); state->control_map = NULL; } if (state->priority_map) { gfx_free_pixmap(state->driver, state->priority_map); state->priority_map = NULL; } if (state->static_priority_map) { gfx_free_pixmap(state->driver, state->static_priority_map); state->static_priority_map = NULL; } if (state->mouse_pointer_bg) { gfx_free_pixmap(state->driver, state->mouse_pointer_bg); state->mouse_pointer_bg = NULL; } state->driver->exit(state->driver); return GFX_OK; } int gfxop_have_mouse(gfx_state_t *state) { return state->driver->capabilities & GFX_CAPABILITY_MOUSE_SUPPORT; } static int _gfxop_scan_one_bitmask(gfx_pixmap_t *pixmap, rect_t zone) { int retval = 0; int pixmap_xscale = pixmap->index_xl / 320; int pixmap_yscale = pixmap->index_yl / 200; int line_width = pixmap_yscale * pixmap->index_xl; int startindex = (line_width * zone.y) + (zone.x * pixmap_xscale); startindex += pixmap_xscale >> 1; /* Center on X */ startindex += (pixmap_yscale >> 1) * pixmap->index_xl; /* Center on Y */ if (_gfxop_clip(&zone, gfx_rect(0, 0, pixmap->index_xl, pixmap->index_yl))) return 0; while (zone.yl--) { int i; for (i = 0; i < (zone.xl * pixmap_xscale); i += pixmap_xscale) retval |= (1 << ((pixmap->index_data[startindex + i]) & 0xf)); startindex += line_width; } return retval; } int gfxop_scan_bitmask(gfx_state_t *state, rect_t area, gfx_map_mask_t map) { gfxr_pic_t *pic = (state->pic_unscaled)? state->pic_unscaled : state->pic; int retval = 0; _gfxop_clip(&area, gfx_rect(0, 10, 320, 200)); if (area.xl <= 0 || area.yl <= 0) return 0; if (map & GFX_MASK_VISUAL) retval |= _gfxop_scan_one_bitmask(pic->visual_map, area); if (map & GFX_MASK_PRIORITY) retval |= _gfxop_scan_one_bitmask(state->priority_map, area); if (map & GFX_MASK_CONTROL) retval |= _gfxop_scan_one_bitmask(state->control_map, area); return retval; } #define MIN_X 0 #define MIN_Y 0 #define MAX_X 319 #define MAX_Y 199 int gfxop_set_clip_zone(gfx_state_t *state, rect_t zone) { int xfact, yfact; BASIC_CHECKS(GFX_ERROR); DDIRTY(stderr, "-- Setting clip zone %d %d %d %d\n", GFX_PRINT_RECT(zone)); xfact = state->driver->mode->xfact; yfact = state->driver->mode->yfact; if (zone.x < MIN_X) { zone.xl -= (zone.x - MIN_X); zone.x = MIN_X; } if (zone.y < MIN_Y) { zone.yl -= (zone.y - MIN_Y); zone.y = MIN_Y; } if (zone.x + zone.xl > MAX_X) zone.xl = MAX_X + 1 - zone.x; if (zone.y + zone.yl > MAX_Y) zone.yl = MAX_Y + 1 - zone.y; memcpy(&(state->clip_zone_unscaled), &zone, sizeof(rect_t)); state->clip_zone.x = state->clip_zone_unscaled.x * xfact; state->clip_zone.y = state->clip_zone_unscaled.y * yfact; state->clip_zone.xl = state->clip_zone_unscaled.xl * xfact; state->clip_zone.yl = state->clip_zone_unscaled.yl * yfact; return GFX_OK; } int gfxop_set_color(gfx_state_t *state, gfx_color_t *color, int r, int g, int b, int a, int priority, int control) { gfx_pixmap_color_t pixmap_color = {0}; int error_code; int mask = ((r >= 0 && g >= 0 && b >= 0) ? GFX_MASK_VISUAL : 0) | ((priority >= 0)? GFX_MASK_PRIORITY : 0) | ((control >= 0)? GFX_MASK_CONTROL : 0); BASIC_CHECKS(GFX_FATAL); if (PALETTE_MODE && a >= GFXOP_ALPHA_THRESHOLD) mask &= ~GFX_MASK_VISUAL; color->mask = mask; color->priority = priority; color->control = control; if (mask & GFX_MASK_VISUAL) { color->visual.r = r; color->visual.g = g; color->visual.b = b; color->alpha = a; if (PALETTE_MODE) { pixmap_color.r = r; pixmap_color.g = g; pixmap_color.b = b; pixmap_color.global_index = GFX_COLOR_INDEX_UNMAPPED; if ((error_code = gfx_alloc_color(state->driver->mode->palette, &pixmap_color))) { if (error_code < 0) { GFXWARN("Could not get color entry for %02x/%02x/%02x\n", r, g, b); return error_code; } else if ((error_code = state->driver->set_palette(state->driver, pixmap_color.global_index, (byte) r, (byte) g, (byte) b))) { GFXWARN("Graphics driver failed to set color index %d to (%02x/%02x/%02x)\n", pixmap_color.global_index, r, g, b); return error_code; } } color->visual.global_index = pixmap_color.global_index; } } return GFX_OK; } int gfxop_set_system_color(gfx_state_t *state, gfx_color_t *color) { gfx_palette_color_t *palette_colors; BASIC_CHECKS(GFX_FATAL); if (!PALETTE_MODE) return GFX_OK; if (color->visual.global_index < 0 || color->visual.global_index >= state->driver->mode->palette->max_colors_nr) { GFXERROR("Attempt to set invalid color index %02x as system color\n", color->visual.global_index); return GFX_ERROR; } palette_colors = state->driver->mode->palette->colors; palette_colors[color->visual.global_index].lockers = GFX_COLOR_SYSTEM; return GFX_OK; } int gfxop_free_color(gfx_state_t *state, gfx_color_t *color) { gfx_palette_color_t *palette_color = {0}; gfx_pixmap_color_t pixmap_color = {0}; int error_code; BASIC_CHECKS(GFX_FATAL); if (!PALETTE_MODE) return GFX_OK; if (color->visual.global_index < 0 || color->visual.global_index >= state->driver->mode->palette->max_colors_nr) { GFXERROR("Attempt to free invalid color index %02x\n", color->visual.global_index); return GFX_ERROR; } pixmap_color.global_index = color->visual.global_index; palette_color = state->driver->mode->palette->colors + pixmap_color.global_index; pixmap_color.r = palette_color->r; pixmap_color.g = palette_color->g; pixmap_color.b = palette_color->b; if ((error_code = gfx_free_color(state->driver->mode->palette, &pixmap_color))) { GFXWARN("Failed to free color with color index %02x\n", color->visual.global_index); return error_code; } return GFX_OK; } /******************************/ /* Generic drawing operations */ /******************************/ static int line_check_bar(int *start, int *length, int clipstart, int cliplength) { int overlength; if (*start < clipstart) { *length -= (clipstart - *start); *start = clipstart; } overlength = 1 + (*start + *length) - (clipstart + cliplength); if (overlength > 0) *length -= overlength; return (*length < 0); } static void clip_line_partial(float *start, float *end, float delta_val, float pos_val, float start_val, float end_val) { float my_start = (start_val - pos_val) * delta_val; float my_end = (end_val - pos_val) * delta_val; if (my_end < *end) *end = my_end; if (my_start > *start) *start = my_start; } static int line_clip(rect_t *line, rect_t clip, int xfact, int yfact) /* returns 1 if nothing is left, or 0 if part of the line is in the clip window */ { /* Compensate for line thickness (should match precisely) */ clip.xl -= xfact; clip.yl -= yfact; if (!line->xl) {/* vbar */ if (line->x < clip.x || line->x >= (clip.x + clip.xl)) return 1; return line_check_bar(&(line->y), &(line->yl), clip.y, clip.yl); } else if (!line->yl) {/* hbar */ if (line->y < clip.y || line->y >= (clip.y + clip.yl)) return 1; return line_check_bar(&(line->x), &(line->xl), clip.x, clip.xl); } else { /* "normal" line */ float start = 0.0, end = 1.0; float xv = (float) line->xl; float yv = (float) line->yl; if (line->xl < 0) clip_line_partial(&start, &end, (float) (1.0 / xv), (float) line->x, (float) (clip.x + clip.xl), (float) clip.x); else clip_line_partial(&start, &end, (float) (1.0 / xv), (float) line->x, (float) clip.x, (float) (clip.x + clip.xl)); if (line->yl < 0) clip_line_partial(&start, &end, (float) (1.0 / yv), (float) line->y, (float) (clip.y + clip.yl), (float) clip.y); else clip_line_partial(&start, &end, (float) (1.0 / yv), (float) line->y, (float) clip.y, (float) (clip.y + clip.yl)); line->x += (int) (xv * start); line->y += (int) (yv * start); line->xl = (int) (xv * (end-start)); line->yl = (int) (yv * (end-start)); return (start > 1.0 || end < 0.0); } return 0; } static int point_clip(point_t *start, point_t *end, rect_t clip, int xfact, int yfact) { rect_t line = gfx_rect(start->x, start->y, end->x - start->x, end->y - start->y); int retval = line_clip(&line, clip, xfact, yfact); start->x = line.x; start->y = line.y; end->x = line.x + line.xl; end->y = line.y + line.yl; return retval; } static void draw_line_to_control_map(gfx_state_t *state, point_t start, point_t end, gfx_color_t color) { if (color.mask & GFX_MASK_CONTROL) if (!point_clip(&start, &end, state->clip_zone_unscaled, 0, 0)) gfx_draw_line_pixmap_i(state->control_map, start, end, color.control); } static int simulate_stippled_line_draw(gfx_driver_t *driver, int skipone, point_t start, point_t end, gfx_color_t color, gfx_line_mode_t line_mode) /* Draws a stippled line if this isn't supported by the driver (skipone is ignored ATM) */ { int xl = end.x - start.x; int yl = end.y - start.y; int stepwidth = (xl)? driver->mode->xfact : driver->mode->yfact; int dbl_stepwidth = 2*stepwidth; int linelength = (line_mode == GFX_LINE_MODE_FINE)? stepwidth - 1 : 0; int *posvar; int length; int delta; int length_left; if (!xl) { /* xl = 0, so we move along yl */ posvar = &start.y; length = yl; delta = (yl < 0)? -dbl_stepwidth : dbl_stepwidth; } else { assert (!yl); /* We don't do diagonals; that's not needed ATM. */ posvar = &start.x; length = xl; delta = (xl < 0)? -dbl_stepwidth : dbl_stepwidth; } length_left = length; if (skipone) { length_left -= stepwidth; *posvar += stepwidth; } length /= delta; length_left -= length * dbl_stepwidth; if (xl) xl = linelength; else yl = linelength; while (length--) { int retval; point_t nextpos = gfx_point(start.x + xl, start.y + yl); if ((retval = driver->draw_line(driver, start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL))) { GFXERROR("Failed to draw partial stippled line (%d,%d) -- (%d,%d)\n", GFX_PRINT_POINT(start), GFX_PRINT_POINT(nextpos)); return retval; } *posvar += delta; } if (length_left) { int retval; point_t nextpos; if (length_left > stepwidth) length_left = stepwidth; if (xl) xl = length_left; else if (yl) yl = length_left; nextpos = gfx_point(start.x + xl, start.y + yl); if ((retval = driver->draw_line(driver, start, nextpos, color, line_mode, GFX_LINE_STYLE_NORMAL))) { GFXERROR("Failed to draw partial stippled line (%d,%d) -- (%d,%d)\n", GFX_PRINT_POINT(start), GFX_PRINT_POINT(nextpos)); return retval; } } return GFX_OK; } static int _gfxop_draw_line_clipped(gfx_state_t *state, point_t start, point_t end, gfx_color_t color, gfx_line_mode_t line_mode, gfx_line_style_t line_style) { int retval; int skipone = (start.x ^ end.y) & 1; /* Used for simulated line stippling */ BASIC_CHECKS(GFX_FATAL); REMOVE_POINTER; /* First, make sure that the line is normalized */ if (start.y > end.y) { point_t swap = start; start = end; end = swap; } if (start.x < state->clip_zone.x || start.y < state->clip_zone.y || end.x >= (state->clip_zone.x + state->clip_zone.xl) || end.y >= (state->clip_zone.y + state->clip_zone.yl)) if (point_clip(&start, &end, state->clip_zone, state->driver->mode->xfact - 1, state->driver->mode->yfact - 1)) return GFX_OK; /* Clipped off */ if (line_style == GFX_LINE_STYLE_STIPPLED) { if (start.x != end.x && start.y != end.y) { GFXWARN("Attempt to draw stippled line which is neither an hbar nor a vbar: (%d,%d) -- (%d,%d)\n", GFX_PRINT_POINT(start), GFX_PRINT_POINT(end)); return GFX_ERROR; } if (!(state->driver->capabilities & GFX_CAPABILITY_STIPPLED_LINES)) return simulate_stippled_line_draw(state->driver, skipone, start, end, color, line_mode); } if (line_mode == GFX_LINE_MODE_FINE && !(state->driver->capabilities & GFX_CAPABILITY_FINE_LINES)) line_mode = GFX_LINE_MODE_FAST; if ((retval = state->driver->draw_line(state->driver, start, end, color, line_mode, line_style))) { GFXERROR("Failed to draw line (%d,%d) -- (%d,%d)\n", GFX_PRINT_POINT(start), GFX_PRINT_POINT(end)); return retval; } return GFX_OK; } int gfxop_draw_line(gfx_state_t *state, point_t start, point_t end, gfx_color_t color, gfx_line_mode_t line_mode, gfx_line_style_t line_style) { int xfact, yfact; BASIC_CHECKS(GFX_FATAL); _gfxop_add_dirty_x(state, gfx_rect(start.x, start.y, end.x - start.x, end.y - start.y)); xfact = state->driver->mode->xfact; yfact = state->driver->mode->yfact; draw_line_to_control_map(state, start, end, color); _gfxop_scale_point(&start, state->driver->mode); _gfxop_scale_point(&end, state->driver->mode); if (line_mode == GFX_LINE_MODE_FINE) { start.x += xfact >> 1; start.y += yfact >> 1; end.x += xfact >> 1; end.y += yfact >> 1; } return _gfxop_draw_line_clipped(state, start, end, color, line_mode, line_style); } int gfxop_draw_rectangle(gfx_state_t *state, rect_t rect, gfx_color_t color, gfx_line_mode_t line_mode, gfx_line_style_t line_style) { int retval = 0; int xfact, yfact; int xunit, yunit; int x, y, xl, yl; point_t upper_left_u, upper_right_u, lower_left_u, lower_right_u; point_t upper_left, upper_right, lower_left, lower_right; BASIC_CHECKS(GFX_FATAL); REMOVE_POINTER; xfact = state->driver->mode->xfact; yfact = state->driver->mode->yfact; if (line_mode == GFX_LINE_MODE_FINE && state->driver->capabilities & GFX_CAPABILITY_FINE_LINES) { xunit = yunit = 1; xl = 1 + (rect.xl - 1) * xfact; yl = 1 + (rect.yl - 1) * yfact; x = rect.x * xfact + (xfact - 1); y = rect.y * yfact + (yfact - 1); } else { xunit = xfact; yunit = yfact; xl = rect.xl * xfact; yl = rect.yl * yfact; x = rect.x * xfact; y = rect.y * yfact; } upper_left_u = gfx_point(rect.x, rect.y); upper_right_u = gfx_point(rect.x + rect.xl, rect.y); lower_left_u = gfx_point(rect.x, rect.y + rect.yl); lower_right_u = gfx_point(rect.x + rect.xl, rect.y + rect.yl); upper_left = gfx_point(x, y); upper_right = gfx_point(x + xl, y); lower_left = gfx_point(x, y + yl); lower_right = gfx_point(x + xl, y + yl); #define PARTIAL_LINE(pt1, pt2) \ retval |= _gfxop_draw_line_clipped(state, pt1, pt2, color, line_mode, line_style); \ draw_line_to_control_map(state, pt1##_u, pt2##_u, color); \ _gfxop_add_dirty_x(state, \ gfx_rect(pt1##_u.x, pt1##_u.y, pt2##_u.x - pt1##_u.x, pt2##_u.y - pt1##_u.y)) PARTIAL_LINE (upper_left, upper_right); PARTIAL_LINE (upper_right, lower_right); PARTIAL_LINE (lower_right, lower_left); PARTIAL_LINE (lower_left, upper_left); #undef PARTIAL_LINE if (retval) { GFXERROR("Failed to draw rectangle (%d,%d)+(%d,%d)\n", rect.x, rect.y, rect.xl, rect.yl); return retval; } return GFX_OK; } #define COLOR_MIX(type, dist) ((color1.type * dist) + (color2.type * (1.0 - dist))) int gfxop_draw_box(gfx_state_t *state, rect_t box, gfx_color_t color1, gfx_color_t color2, gfx_box_shade_t shade_type) { gfx_driver_t *drv = state->driver; int reverse = 0; /* switch color1 and color2 */ float mod_offset = 0.0, mod_breadth = 1.0; /* 0.0 to 1.0: Color adjustment */ gfx_rectangle_fill_t driver_shade_type; rect_t new_box; gfx_color_t draw_color1, draw_color2 = {{0, 0, 0}, 0, 0, 0, 0}; BASIC_CHECKS(GFX_FATAL); REMOVE_POINTER; if (PALETTE_MODE || !(state->driver->capabilities & GFX_CAPABILITY_SHADING)) shade_type = GFX_BOX_SHADE_FLAT; _gfxop_add_dirty(state, box); if (color1.mask & GFX_MASK_CONTROL) { /* Write control block, clipped by 320x200 */ memcpy(&new_box, &box, sizeof(rect_t)); _gfxop_clip(&new_box, gfx_rect(0, 0, 320, 200)); gfx_draw_box_pixmap_i(state->control_map, new_box, color1.control); } _gfxop_scale_rect(&box, state->driver->mode); if (!(color1.mask & (GFX_MASK_VISUAL | GFX_MASK_PRIORITY))) return GFX_OK; /* So long... */ if (box.xl <= 1 || box.yl <= 1) { GFXDEBUG("Attempt to draw box with size %dx%d\n", box.xl, box.yl); return GFX_OK; } memcpy(&new_box, &box, sizeof(rect_t)); if (_gfxop_clip(&new_box, state->clip_zone)) return GFX_OK; switch (shade_type) { case GFX_BOX_SHADE_FLAT: driver_shade_type = GFX_SHADE_FLAT; break; case GFX_BOX_SHADE_LEFT: reverse = 1; case GFX_BOX_SHADE_RIGHT: driver_shade_type = GFX_SHADE_HORIZONTALLY; mod_offset = (float) (((new_box.x - box.x) * 1.0) / (box.xl * 1.0)); mod_breadth = (float) ((new_box.xl * 1.0) / (box.xl * 1.0)); break; case GFX_BOX_SHADE_UP: reverse = 1; case GFX_BOX_SHADE_DOWN: driver_shade_type = GFX_SHADE_VERTICALLY; mod_offset = (float) (((new_box.y - box.y) * 1.0) / (box.yl * 1.0)); mod_breadth = (float) ((new_box.yl * 1.0) / (box.yl * 1.0)); break; default: GFXERROR("Invalid shade type: %d\n", shade_type); return GFX_ERROR; } if (reverse) mod_offset = (float) (1.0 - (mod_offset + mod_breadth)); /* Reverse offset if we have to interpret colors inversely */ if (shade_type == GFX_BOX_SHADE_FLAT) return drv->draw_filled_rect(drv, new_box, color1, color1, GFX_SHADE_FLAT); else { if (PALETTE_MODE) { GFXWARN("Attempting to draw shaded box in palette mode!\n"); return GFX_ERROR; } draw_color1.mask = draw_color2.mask = color1.mask; draw_color1.priority = draw_color2.priority = color1.priority; if (draw_color1.mask & GFX_MASK_VISUAL) { draw_color1.visual.r = (guint8) COLOR_MIX(visual.r, mod_offset); draw_color1.visual.g = (guint8) COLOR_MIX(visual.g, mod_offset); draw_color1.visual.b = (guint8) COLOR_MIX(visual.b, mod_offset); draw_color1.alpha = (guint8) COLOR_MIX(alpha, mod_offset); mod_offset += mod_breadth; draw_color2.visual.r = (guint8) COLOR_MIX(visual.r, mod_offset); draw_color2.visual.g = (guint8) COLOR_MIX(visual.g, mod_offset); draw_color2.visual.b = (guint8) COLOR_MIX(visual.b, mod_offset); draw_color2.alpha = (guint8) COLOR_MIX(alpha, mod_offset); } if (reverse) return drv->draw_filled_rect(drv, new_box, draw_color2, draw_color1, driver_shade_type); else return drv->draw_filled_rect(drv, new_box, draw_color1, draw_color2, driver_shade_type); } } #undef COLOR_MIX int gfxop_fill_box(gfx_state_t *state, rect_t box, gfx_color_t color) { return gfxop_draw_box(state, box, color, color, GFX_BOX_SHADE_FLAT); } static int _gfxop_buffer_propagate_box(gfx_state_t *state, rect_t box, gfx_buffer_t buffer) { int error; if (_gfxop_clip(&box, gfx_rect(0, 0, 320 * state->driver->mode->xfact, 200 * state->driver->mode->yfact))) return GFX_OK; if ((error = state->driver->update(state->driver, box, gfx_point(box.x, box.y), buffer))) { GFXERROR("Error occured while updating region (%d,%d,%d,%d) in buffer %d\n", box.x, box.y, box.xl, box.yl, buffer); return error; } return GFX_OK; } extern int sci0_palette; int gfxop_clear_box(gfx_state_t *state, rect_t box) { BASIC_CHECKS(GFX_FATAL); REMOVE_POINTER; _gfxop_add_dirty(state, box); DDIRTY(stderr, "[] clearing box %d %d %d %d\n", GFX_PRINT_RECT(box)); if (box.x == 29 && box.y == 77 && (sci0_palette == 1)) { BREAKPOINT(); } _gfxop_clip(&box, gfx_rect(0, 0, 320, 200)); #ifdef PRECISE_PRIORITY_MAP if (state->pic_unscaled) gfx_copy_pixmap_box_i(state->priority_map, state->static_priority_map, box); #endif _gfxop_scale_rect(&box, state->driver->mode); return _gfxop_buffer_propagate_box(state, box, GFX_BUFFER_BACK); } int gfxop_set_visible_map(gfx_state_t *state, gfx_map_mask_t visible_map) { switch (visible_map) { case GFX_MASK_VISUAL: state->fullscreen_override = NULL; if (visible_map != state->visible_map) { rect_t rect = gfx_rect(0, 0, 320, 200); gfxop_clear_box(state, rect); gfxop_update_box(state, rect); } break; case GFX_MASK_PRIORITY: state->fullscreen_override = state->priority_map; break; case GFX_MASK_CONTROL: state->fullscreen_override = state->control_map; break; default: fprintf(stderr, "Invalid display map %d selected!\n", visible_map); return GFX_ERROR; } state->visible_map = visible_map; return GFX_OK; } int gfxop_update(gfx_state_t *state) { int retval; BASIC_CHECKS(GFX_FATAL); DRAW_POINTER; retval = _gfxop_clear_dirty_rec(state, state->dirty_rects); state->dirty_rects = NULL; if (state->fullscreen_override) { /* We've been asked to re-draw the active full-screen image, essentially. */ rect_t rect = gfx_rect(0, 0, 320, 200); gfx_xlate_pixmap(state->fullscreen_override, state->driver->mode, GFX_XLATE_FILTER_NONE); gfxop_draw_pixmap(state, state->fullscreen_override, rect, gfx_point(0,0)); retval |= _gfxop_update_box(state, rect); } if (retval) { GFXERROR("Clearing the dirty rectangles failed!\n"); } if (state->tag_mode) { /* This usually happens after a pic and all resources have been drawn */ gfxr_free_tagged_resources(state->driver, state->resstate); state->tag_mode = 0; } return retval; } int gfxop_update_box(gfx_state_t *state, rect_t box) { BASIC_CHECKS(GFX_FATAL); DRAW_POINTER; if (state->disable_dirty) _gfxop_update_box(state, box); else _gfxop_add_dirty(state, box); return gfxop_update(state); } int gfxop_enable_dirty_frames(gfx_state_t *state) { BASIC_CHECKS(GFX_ERROR); state->disable_dirty = 0; return GFX_OK; } int gfxop_disable_dirty_frames(gfx_state_t *state) { BASIC_CHECKS(GFX_ERROR); state->disable_dirty = 1; return GFX_OK; } /**********************/ /* Pointer and IO ops */ /**********************/ #define SECONDS_OF_DAY (24*60*60) #define MILLION 1000000 /* Sure, this may seem silly, but it's too easy to miss a zero...) */ #define GFXOP_FULL_POINTER_REFRESH if (_gfxop_full_pointer_refresh(state)) { GFXERROR("Failed to do full pointer refresh!\n"); return GFX_ERROR; } static int _gfxop_full_pointer_refresh(gfx_state_t *state) { rect_t pointer_bounds; rect_t old_pointer_bounds = {0, 0, 0, 0}; int new_x = state->driver->pointer_x; int new_y = state->driver->pointer_y; if (new_x != state->old_pointer_draw_pos.x || new_y != state->old_pointer_draw_pos.y) { point_t pp_new = gfx_point(new_x / state->driver->mode->xfact, new_y / state->driver->mode->yfact); if (!_gfxop_get_pointer_bounds(state, &pointer_bounds)) { memcpy(&old_pointer_bounds, &(state->pointer_bg_zone), sizeof(rect_t)); REMOVE_POINTER; state->pointer_pos = pp_new; DRAW_POINTER; if (_gfxop_buffer_propagate_box(state, pointer_bounds, GFX_BUFFER_FRONT)) return 1; if (_gfxop_buffer_propagate_box(state, old_pointer_bounds, GFX_BUFFER_FRONT)) return 1; state->old_pointer_draw_pos = gfx_point(new_x, new_y); } else state->pointer_pos = pp_new; } return 0; } int gfxop_usleep(gfx_state_t *state, long usecs) { long time, utime; long wakeup_time, wakeup_utime; long add_seconds; int retval = GFX_OK; BASIC_CHECKS(GFX_FATAL); sci_gettime(&wakeup_time, &wakeup_utime); wakeup_utime += usecs; add_seconds = (wakeup_utime / MILLION); wakeup_time += add_seconds; wakeup_utime -= (MILLION * add_seconds); do { GFXOP_FULL_POINTER_REFRESH; sci_gettime(&time, &utime); usecs = (wakeup_time - time) * MILLION + wakeup_utime - utime; } while ((usecs > 0) && !(retval = state->driver->usec_sleep(state->driver, usecs))); if (retval) { GFXWARN("Waiting failed\n"); } return retval; } int _gfxop_set_pointer(gfx_state_t *state, gfx_pixmap_t *pxm) { rect_t old_pointer_bounds = {0}; rect_t pointer_bounds = {0}; int retval = -1; int draw_old; int draw_new = 0; BASIC_CHECKS(GFX_FATAL); draw_old = state->mouse_pointer != NULL; if (state->driver->capabilities & GFX_CAPABILITY_MOUSE_POINTER) { if (draw_old && state->mouse_pointer->colors_nr > 2) draw_old = state->driver->capabilities & GFX_CAPABILITY_COLOR_MOUSE_POINTER; if (!draw_old && state->mouse_pointer && (state->driver->capabilities & GFX_CAPABILITY_POINTER_PIXMAP_REGISTRY)) if ((retval = state->driver->unregister_pixmap(state->driver, state->mouse_pointer))){ GFXERROR("Pointer un-registration failed!\n"); return retval; } if (pxm == NULL || (state->driver->capabilities & GFX_CAPABILITY_COLOR_MOUSE_POINTER) || pxm->colors_nr <= 2) { if (state->driver->capabilities & GFX_CAPABILITY_POINTER_PIXMAP_REGISTRY) { if ((pxm) && (retval = state->driver->register_pixmap(state->driver, pxm))) { GFXERROR("Pixmap-registering a new mouse pointer failed!\n"); return retval; } } draw_new = 0; state->driver->set_pointer(state->driver, pxm); state->mouse_pointer_in_hw = 1; } else { draw_new = 1; state->mouse_pointer_in_hw = 0; } } else draw_new = 1; if (!state->mouse_pointer_in_hw) draw_old = state->mouse_pointer != NULL; if (draw_old) { _gfxop_get_pointer_bounds(state, &old_pointer_bounds); REMOVE_POINTER; } if (draw_new) { state->mouse_pointer = pxm; DRAW_POINTER; _gfxop_get_pointer_bounds(state, &pointer_bounds); } if (draw_new && state->mouse_pointer) _gfxop_buffer_propagate_box(state, pointer_bounds, GFX_BUFFER_FRONT); if (draw_old) _gfxop_buffer_propagate_box(state, old_pointer_bounds, GFX_BUFFER_FRONT); if (state->mouse_pointer == NULL) state->mouse_pointer_visible = 0; else if (!state->mouse_pointer_visible) state->mouse_pointer_visible = 1; /* else don't touch it, as it might be VISIBLE_BUT_CLIPPED! */ return GFX_OK; } int gfxop_set_pointer_cursor(gfx_state_t *state, int nr) { gfx_pixmap_t *new_pointer = NULL; BASIC_CHECKS(GFX_FATAL); if (nr == GFXOP_NO_POINTER) new_pointer = NULL; else { new_pointer = gfxr_get_cursor(state->resstate, nr); if (!new_pointer) { GFXWARN("Attempt to set invalid pointer #%d\n", nr); } } return _gfxop_set_pointer(state, new_pointer); } int gfxop_set_pointer_view(gfx_state_t *state, int nr, int loop, int cel, point_t *hotspot) { int real_loop = loop; int real_cel = cel; gfx_pixmap_t *new_pointer = NULL; BASIC_CHECKS(GFX_FATAL); new_pointer = _gfxr_get_cel(state, nr, &real_loop, &real_cel, 0); /* FIXME: For now, don't palettize pointers */ if (hotspot) { new_pointer->xoffset = hotspot->x; new_pointer->yoffset = hotspot->y; } if (!new_pointer) { GFXWARN("Attempt to set invalid pointer #%d\n", nr); return GFX_ERROR; } else { if (real_loop != loop || real_cel != cel) { GFXDEBUG("Changed loop/cel from %d/%d to %d/%d in view %d\n", loop, cel, real_loop, real_cel, nr); } return _gfxop_set_pointer(state, new_pointer); } } int gfxop_set_pointer_position(gfx_state_t *state, point_t pos) { BASIC_CHECKS(GFX_ERROR); state->pointer_pos = pos; if (pos.x > 320 || pos.y > 200) { GFXWARN("Attempt to place pointer at invalid coordinates (%d, %d)\n", pos.x, pos.y); return 0; /* Not fatal */ } state->driver->pointer_x = pos.x * state->driver->mode->xfact; state->driver->pointer_y = pos.y * state->driver->mode->yfact; GFXOP_FULL_POINTER_REFRESH; return 0; } #define SCANCODE_ROWS_NR 3 struct scancode_row { int offset; const char *keys; } scancode_rows[SCANCODE_ROWS_NR] = { {0x10, "QWERTYUIOP[]"}, {0x1e, "ASDFGHJKL;'\\"}, {0x2c, "ZXCVBNM,./"} }; static int _gfxop_scancode(int ch) /* Calculates a PC keyboard scancode from a character */ { int row; int c = toupper((char)ch); for (row = 0; row < SCANCODE_ROWS_NR; row++) { const char *keys = scancode_rows[row].keys; int offset = scancode_rows[row].offset; while (*keys) { if (*keys == c) return offset << 8; offset++; keys++; } } return ch; /* not found */ } /* static */ int _gfxop_shiftify(int c) { char shifted_numbers[] = ")!@#$%^&*("; if (c < 256) { c = toupper((char)c); if (c >= 'A' && c <= 'Z') return c; if (c >= '0' && c <= '9') return shifted_numbers[c-'0']; switch (c) { case SCI_K_TAB: return SCI_K_SHIFT_TAB; case ']': return '}'; case '[': return '{'; case '`': return '~'; case '-': return '_'; case '=': return '+'; case ';': return ':'; case '\'': return '"'; case '\\': return '|'; case ',': return '<'; case '.': return '>'; case '/': return '?'; default: return c; /* No match */ } } switch (c) { case SCI_K_F1 : return SCI_K_SHIFT_F1; case SCI_K_F2 : return SCI_K_SHIFT_F2; case SCI_K_F3 : return SCI_K_SHIFT_F3; case SCI_K_F4 : return SCI_K_SHIFT_F4; case SCI_K_F5 : return SCI_K_SHIFT_F5; case SCI_K_F6 : return SCI_K_SHIFT_F6; case SCI_K_F7 : return SCI_K_SHIFT_F7; case SCI_K_F8 : return SCI_K_SHIFT_F8; case SCI_K_F9 : return SCI_K_SHIFT_F9; case SCI_K_F10 : return SCI_K_SHIFT_F10; } return c; } static int _gfxop_numlockify(int c) { switch (c) { case SCI_K_DELETE: return '.'; case SCI_K_INSERT: return '0'; case SCI_K_END: return '1'; case SCI_K_DOWN: return '2'; case SCI_K_PGDOWN: return '3'; case SCI_K_LEFT: return '4'; case SCI_K_CENTER: return '5'; case SCI_K_RIGHT: return '6'; case SCI_K_HOME: return '7'; case SCI_K_UP: return '8'; case SCI_K_PGUP: return '9'; default: return c; /* Unchanged */ } } sci_event_t gfxop_get_event(gfx_state_t *state, unsigned int mask) { sci_event_t error_event = { SCI_EVT_ERROR, 0, 0 }; sci_event_t event; event.data = 0; event.buckybits = 0; gfx_input_event_t **seekerp = &(state->events); BASIC_CHECKS(error_event); if (_gfxop_remove_pointer(state)) { GFXERROR("Failed to remove pointer before processing event!\n"); } while (*seekerp && !((*seekerp)->event.type & mask)) seekerp = &((*seekerp)->next); if (*seekerp) { gfx_input_event_t *goner = *seekerp; event = goner->event; *seekerp = goner->next; free(goner); } else { event.type = 0; if (!(mask & SCI_EVT_NONBLOCK)) { do { if (event.type) { *seekerp = (gfx_input_event_t*)sci_malloc(sizeof(gfx_input_event_t)); (*seekerp)->next = NULL; event.data = (char) (event.data); /* Clip illegal bits */ (*seekerp)->event = event; seekerp = &((*seekerp)->next); } event = state->driver->get_event(state->driver); } while (event.type && !(event.type & mask)); } } if (_gfxop_full_pointer_refresh(state)) { GFXERROR("Failed to update the mouse pointer!\n"); return error_event; } if (event.type == SCI_EVT_KEYBOARD && !(state->driver->capabilities & GFX_CAPABILITY_KEYTRANSLATE)) { /* Do we still have to translate the key? */ event.character = event.data; /* Scancodify if appropriate */ if (event.buckybits & SCI_EVM_ALT) event.character = _gfxop_scancode(event.character); /* Shift if appropriate */ else if (((event.buckybits & (SCI_EVM_RSHIFT | SCI_EVM_LSHIFT)) && !(event.buckybits & SCI_EVM_CAPSLOCK)) || (!(event.buckybits & (SCI_EVM_RSHIFT | SCI_EVM_LSHIFT)) && (event.buckybits & SCI_EVM_CAPSLOCK))) event.character = _gfxop_shiftify(event.character); /* Numlockify if appropriate */ else if (event.buckybits & SCI_EVM_NUMLOCK) event.data = _gfxop_numlockify(event.data); } return event; } /*******************/ /* View operations */ /*******************/ int gfxop_lookup_view_get_loops(gfx_state_t *state, int nr) { int loop = 0, cel = 0; gfxr_view_t *view = NULL; BASIC_CHECKS(GFX_ERROR); view = gfxr_get_view(state->resstate, nr, &loop, &cel, 0); if (!view) { GFXWARN("Attempt to retreive number of loops from invalid view %d\n", nr); return 0; } return view->loops_nr; } int gfxop_lookup_view_get_cels(gfx_state_t *state, int nr, int loop) { int real_loop = loop, cel = 0; gfxr_view_t *view = NULL; BASIC_CHECKS(GFX_ERROR); view = gfxr_get_view(state->resstate, nr, &real_loop, &cel, 0); if (!view) { GFXWARN("Attempt to retreive number of cels from invalid/broken view %d\n", nr); return 0; } else if (real_loop != loop) { GFXWARN("Loop number was corrected from %d to %d in view %d\n", loop, real_loop, nr); } return view->loops[real_loop].cels_nr; } int gfxop_check_cel(gfx_state_t *state, int nr, int *loop, int *cel) { BASIC_CHECKS(GFX_ERROR); if (!gfxr_get_view(state->resstate, nr, loop, cel, 0)) { GFXWARN("Attempt to verify loop/cel values for invalid view %d\n", nr); return GFX_ERROR; } return GFX_OK; } int gfxop_overflow_cel(gfx_state_t *state, int nr, int *loop, int *cel) { int loop_v = *loop; int cel_v = *cel; BASIC_CHECKS(GFX_ERROR); if (!gfxr_get_view(state->resstate, nr, &loop_v, &cel_v, 0)) { GFXWARN("Attempt to verify loop/cel values for invalid view %d\n", nr); return GFX_ERROR; } if (loop_v != *loop) *loop = 0; if (loop_v != *loop || cel_v != *cel) *cel = 0; return GFX_OK; } int gfxop_get_cel_parameters(gfx_state_t *state, int nr, int loop, int cel, int *width, int *height, point_t *offset) { gfxr_view_t *view = NULL; gfx_pixmap_t *pxm = NULL; BASIC_CHECKS(GFX_ERROR); if (!(view = gfxr_get_view(state->resstate, nr, &loop, &cel, 0))) { GFXWARN("Attempt to get cel parameters for invalid view %d\n", nr); return GFX_ERROR; } pxm = view->loops[loop].cels[cel]; *width = pxm->index_xl; *height = pxm->index_yl; offset->x = pxm->xoffset; offset->y = pxm->yoffset; return GFX_OK; } static int _gfxop_draw_cel_buffer(gfx_state_t *state, int nr, int loop, int cel, point_t pos, gfx_color_t color, int static_buf, int palette) { int priority = (color.mask & GFX_MASK_PRIORITY)? color.priority : -1; int control = (color.mask & GFX_MASK_CONTROL)? color.control : -1; gfxr_view_t *view = NULL; gfx_pixmap_t *pxm = NULL; int old_x, old_y; BASIC_CHECKS(GFX_FATAL); if (!(view = gfxr_get_view(state->resstate, nr, &loop, &cel, palette))) { GFXWARN("Attempt to draw loop/cel %d/%d in invalid view %d\n", loop, cel, nr); return GFX_ERROR; } pxm = view->loops[loop].cels[cel]; old_x = pos.x -= pxm->xoffset; old_y = pos.y -= pxm->yoffset; pos.x *= state->driver->mode->xfact; pos.y *= state->driver->mode->yfact; if (!static_buf) _gfxop_add_dirty(state, gfx_rect(old_x, old_y, pxm->index_xl, pxm->index_yl)); return _gfxop_draw_pixmap(state->driver, pxm, priority, control, gfx_rect(0, 0, pxm->xl, pxm->yl), gfx_rect(pos.x, pos.y, pxm->xl, pxm->yl), state->clip_zone, static_buf , state->control_map, static_buf ? state->static_priority_map : state->priority_map); } int gfxop_draw_cel(gfx_state_t *state, int nr, int loop, int cel, point_t pos, gfx_color_t color, int palette) { return _gfxop_draw_cel_buffer(state, nr, loop, cel, pos, color, 0, palette); } int gfxop_draw_cel_static(gfx_state_t *state, int nr, int loop, int cel, point_t pos, gfx_color_t color, int palette) { int retval; rect_t oldclip = state->clip_zone; state->clip_zone = gfx_rect_fullscreen; _gfxop_scale_rect(&(state->clip_zone), state->driver->mode); retval = gfxop_draw_cel_static_clipped(state, nr, loop, cel, pos, color, palette); /* Except that the area it's clipped against is... unusual ;-) */ state->clip_zone = oldclip; return retval; } int gfxop_draw_cel_static_clipped(gfx_state_t *state, int nr, int loop, int cel, point_t pos, gfx_color_t color, int palette) { return _gfxop_draw_cel_buffer(state, nr, loop, cel, pos, color, 1, palette); } /******************/ /* Pic operations */ /******************/ static int _gfxop_set_pic(gfx_state_t *state) { gfx_copy_pixmap_box_i(state->control_map, state->pic->control_map, gfx_rect(0, 0, 320, 200)); gfx_copy_pixmap_box_i(state->priority_map, state->pic_unscaled->priority_map, gfx_rect(0, 0, 320, 200)); gfx_copy_pixmap_box_i(state->static_priority_map, state->pic_unscaled->priority_map, gfx_rect(0, 0, 320, 200)); _gfxop_install_pixmap(state->driver, state->pic->visual_map); if (state->options->pic0_unscaled) state->pic->priority_map = gfx_pixmap_scale_index_data(state->pic->priority_map, state->driver->mode); return state->driver->set_static_buffer(state->driver, state->pic->visual_map, state->pic->priority_map); } void * gfxop_get_pic_metainfo(gfx_state_t *state) { return (state->pic)? state->pic->internal : NULL; } int gfxop_new_pic(gfx_state_t *state, int nr, int flags, int default_palette) { BASIC_CHECKS(GFX_FATAL); gfxr_tag_resources(state->resstate); state->tag_mode = 1; state->palette_nr = default_palette; state->pic = gfxr_get_pic(state->resstate, nr, GFX_MASK_VISUAL, flags, default_palette, 1); if (state->driver->mode->xfact == 1 && state->driver->mode->yfact == 1) state->pic_unscaled = state->pic; else state->pic_unscaled = gfxr_get_pic(state->resstate, nr, GFX_MASK_VISUAL, flags, default_palette, 0); if (!state->pic || !state->pic_unscaled) { GFXERROR("Could not retreive background pic %d!\n", nr); if (state->pic) { GFXERROR(" -- Inconsistency: scaled pic _was_ retreived!\n"); } if (state->pic_unscaled) { GFXERROR(" -- Inconsistency: unscaled pic _was_ retreived!\n"); } state->pic = state->pic_unscaled = NULL; return GFX_ERROR; } state->pic_nr = nr; return _gfxop_set_pic(state); } int gfxop_add_to_pic(gfx_state_t *state, int nr, int flags, int default_palette) { BASIC_CHECKS(GFX_FATAL); if (!state->pic) { GFXERROR("Attempt to add to pic with no pic active!\n"); return GFX_ERROR; } if (!(state->pic = gfxr_add_to_pic(state->resstate, state->pic_nr, nr, GFX_MASK_VISUAL, flags, state->palette_nr, default_palette, 1))) { GFXERROR("Could not add pic #%d to pic #%d!\n", state->pic_nr, nr); return GFX_ERROR; } state->pic_unscaled = gfxr_add_to_pic(state->resstate, state->pic_nr, nr, GFX_MASK_VISUAL, flags, state->palette_nr, default_palette, 1); return _gfxop_set_pic(state); } /*******************/ /* Text operations */ /*******************/ int gfxop_get_font_height(gfx_state_t *state, int font_nr) { gfx_bitmap_font_t *font; BASIC_CHECKS(GFX_FATAL); font = gfxr_get_font(state->resstate, font_nr, 0); if (!font) return GFX_ERROR; return font->line_height; } int gfxop_get_text_params(gfx_state_t *state, int font_nr, const char *text, int maxwidth, int *width, int *height, int text_flags, int *lines_nr, int *lineheight, int *lastline_width) { text_fragment_t *textsplits; gfx_bitmap_font_t *font; BASIC_CHECKS(GFX_FATAL); font = gfxr_get_font(state->resstate, font_nr, 0); if (!font) { GFXERROR("Attempt to calculate text size with invalid font #%d\n", font_nr); *width = *height = 0; return GFX_ERROR; } textsplits = gfxr_font_calculate_size(font, maxwidth, text, width, height, lines_nr, lineheight, lastline_width, (state->options->workarounds & GFX_WORKAROUND_WHITESPACE_COUNT) | text_flags); if (!textsplits) { GFXERROR("Could not calculate text size!"); *width = *height = 0; return GFX_ERROR; } free(textsplits); return GFX_OK; } #define COL_XLATE(des,src) \ des = src.visual; /* The new gfx_color_t structure makes things a lot easier :-) */ /* \ if (gfxop_set_color(state, &src, \ src.visual.r, \ src.visual.g, \ src.visual.b, \ src.alpha, \ src.priority, \ src.control)) \ { \ GFXERROR("Unable to set up colors"); \ return NULL; \ } */ gfx_text_handle_t * gfxop_new_text(gfx_state_t *state, int font_nr, char *text, int maxwidth, gfx_alignment_t halign, gfx_alignment_t valign, gfx_color_t color1, gfx_color_t color2, gfx_color_t bg_color, int flags) { gfx_text_handle_t *handle = {0}; gfx_bitmap_font_t *font = {0}; int i; gfx_pixmap_color_t pxm_col1, pxm_col2, pxm_colbg= {0}; BASIC_CHECKS(NULL); COL_XLATE(pxm_col1, color1); COL_XLATE(pxm_col2, color2); COL_XLATE(pxm_colbg, bg_color); font = gfxr_get_font(state->resstate, font_nr, 0); if (!font) { GFXERROR("Attempt to draw text with invalid font #%d\n", font_nr); return NULL; } handle = (gfx_text_handle_t*)sci_malloc(sizeof(gfx_text_handle_t)); handle->text = (char*)sci_malloc(strlen(text) + 1); strcpy(handle->text, text); handle->halign = halign; handle->valign = valign; handle->line_height = font->line_height; handle->lines = gfxr_font_calculate_size(font, maxwidth, handle->text, &(handle->width), &(handle->height), &(handle->lines_nr), NULL, NULL, ((state->options->workarounds & GFX_WORKAROUND_WHITESPACE_COUNT)? GFXR_FONT_FLAG_COUNT_WHITESPACE : 0) | flags); if (!handle->lines) { free(handle->text); free(handle); GFXERROR("Could not calculate text parameters in font #%d\n", font_nr); return NULL; } if (flags & GFXR_FONT_FLAG_NO_NEWLINES) { handle->lines_nr = 1; handle->lines->length = strlen(text); } handle->text_pixmaps = (gfx_pixmap_t**)sci_malloc(sizeof(gfx_pixmap_t *) * handle->lines_nr); for (i = 0; i < handle->lines_nr; i++) { int chars_nr = handle->lines[i].length; handle->text_pixmaps[i] = gfxr_draw_font(font, handle->lines[i].offset, chars_nr, (color1.mask & GFX_MASK_VISUAL)? &pxm_col1 : NULL, (color2.mask & GFX_MASK_VISUAL)? &pxm_col2 : NULL, (bg_color.mask & GFX_MASK_VISUAL)? &pxm_colbg : NULL); if (!handle->text_pixmaps[i]) { int j; for (j = 0; j < i; j++) gfx_free_pixmap(state->driver, handle->text_pixmaps[j]); sci_free(handle->text_pixmaps); sci_free(handle->text); sci_free(handle->lines); GFXERROR("Failed to draw text pixmap for line %d/%d\n", i, handle->lines_nr); sci_free(handle); return NULL; } } handle->font = font; handle->priority = (color1.mask & GFX_MASK_PRIORITY)? color1.priority : -1; handle->control = (color1.mask & GFX_MASK_CONTROL)? color1.control : -1; return handle; } int gfxop_free_text(gfx_state_t *state, gfx_text_handle_t *handle) { int j; BASIC_CHECKS(GFX_ERROR); if (handle->text_pixmaps) { for (j = 0; j < handle->lines_nr; j++) gfx_free_pixmap(state->driver, handle->text_pixmaps[j]); free(handle->text_pixmaps); } free(handle->text); free(handle->lines); free(handle); return GFX_OK; } int gfxop_draw_text(gfx_state_t *state, gfx_text_handle_t *handle, rect_t zone) { int line_height; rect_t pos; int i; BASIC_CHECKS(GFX_FATAL); REMOVE_POINTER; if (!handle) { GFXERROR("Attempt to draw text with NULL handle!\n"); return GFX_ERROR; } if (!handle->lines_nr) { GFXDEBUG("Skipping draw_text operation because number of lines is zero\n"); return GFX_OK; } _gfxop_scale_rect(&zone, state->driver->mode); line_height = handle->line_height * state->driver->mode->yfact; pos.y = zone.y; switch (handle->valign) { case ALIGN_TOP: break; case ALIGN_CENTER: pos.y += (zone.yl - (line_height * handle->lines_nr)) >> 1; break; case ALIGN_BOTTOM: pos.y += (zone.yl - (line_height * handle->lines_nr)); break; default: GFXERROR("Invalid vertical alignment %d!\n", handle->valign); return GFX_FATAL; /* Internal error... */ } for (i = 0; i < handle->lines_nr; i++) { gfx_pixmap_t *pxm = handle->text_pixmaps[i]; if (!pxm->data) { gfx_xlate_pixmap(pxm, state->driver->mode, state->options->text_xlate_filter); gfxr_endianness_adjust(pxm, state->driver->mode); /* FIXME: resmgr layer! */ } if (!pxm) { GFXERROR("Could not find text pixmap %d/%d\n", i, handle->lines_nr); return GFX_ERROR; } pos.x = zone.x; switch (handle->halign) { case ALIGN_LEFT: break; case ALIGN_CENTER: pos.x += (zone.xl - pxm->xl) >> 1; break; case ALIGN_RIGHT: pos.x += (zone.xl - pxm->xl); break; default: GFXERROR("Invalid vertical alignment %d!\n", handle->valign); return GFX_FATAL; /* Internal error... */ } pos.xl = pxm->xl; pos.yl = pxm->yl; _gfxop_add_dirty(state, pos); _gfxop_draw_pixmap(state->driver, pxm, handle->priority, handle->control, gfx_rect(0, 0, pxm->xl, pxm->yl), pos, state->clip_zone, 0, state->control_map, state->priority_map); pos.y += line_height; } return GFX_OK; } gfx_pixmap_t * gfxop_grab_pixmap(gfx_state_t *state, rect_t area) { gfx_pixmap_t *pixmap = NULL; rect_t resultzone; /* Ignored for this application */ BASIC_CHECKS(NULL); if (_gfxop_remove_pointer(state)) { GFXERROR("Could not remove pointer!\n"); return NULL; } _gfxop_scale_rect(&area, state->driver->mode); if (_gfxop_grab_pixmap(state, &pixmap, area.x, area.y, area.xl, area.yl, 0, &resultzone)) return NULL; /* area CUT the visual screen had a null or negative size */ pixmap->flags |= GFX_PIXMAP_FLAG_PALETTE_SET | GFX_PIXMAP_FLAG_DONT_UNALLOCATE_PALETTE; return pixmap; } int gfxop_draw_pixmap(gfx_state_t *state, gfx_pixmap_t *pxm, rect_t zone, point_t pos) { rect_t target; BASIC_CHECKS(GFX_ERROR); if (!pxm) { GFXERROR("Attempt to draw NULL pixmap!\n"); return GFX_ERROR; } REMOVE_POINTER; target = gfx_rect(pos.x, pos.y, zone.xl, zone.yl); _gfxop_add_dirty(state, target); if (!pxm) { GFXERROR("Attempt to draw_pixmap with pxm=NULL\n"); return GFX_ERROR; } _gfxop_scale_rect(&zone, state->driver->mode); _gfxop_scale_rect(&target, state->driver->mode); return _gfxop_draw_pixmap(state->driver, pxm, -1, -1, zone, target, gfx_rect(0, 0, 320*state->driver->mode->xfact, 200*state->driver->mode->yfact), 0, NULL, NULL); } int gfxop_free_pixmap(gfx_state_t *state, gfx_pixmap_t *pxm) { BASIC_CHECKS(GFX_ERROR); gfx_free_pixmap(state->driver, pxm); return GFX_OK; }