/*
* Clear the specified area of a window and possibly make an exposure event.
* This sets the area window to its background color or pixmap. If the
* exposeflag is nonzero, then this also creates an exposure event for the
* window.
*/
void
GsWpClearWindow(GR_WINDOW *wp, GR_COORD x, GR_COORD y, GR_SIZE width,
GR_SIZE height, GR_BOOL exposeflag)
{
if (!wp->realized || !wp->output)
return;
/*
* Reduce the arguments so that they actually lie within the window.
*/
if (x < 0) {
width += x;
x = 0;
}
if (y < 0) {
height += y;
y = 0;
}
if (x + width > wp->width)
width = wp->width - x;
if (y + height > wp->height)
height = wp->height - y;
/*
* Now see if the region is really in the window. If not, then
* do nothing.
*/
if ((x >= wp->width) || (y >= wp->height) || (width <= 0) ||
(height <= 0))
return;
/*
* Draw the background of the window.
* Invalidate the current graphics context since
* we are changing the foreground color and mode.
*/
GsSetClipWindow(wp, NULL, 0);
curgcp = NULL;
GdSetFillMode(GR_FILL_SOLID);
if (!(wp->props & GR_WM_PROPS_NOBACKGROUND)) {
GdSetMode(GR_MODE_COPY);
GdSetForegroundColor(wp->psd, wp->background);
if (wp->bgpixmap) {
GsWpDrawBackgroundPixmap(wp, wp->bgpixmap, x, y,
width, height);
} else {
GdFillRect(wp->psd, wp->x + x, wp->y + y, width,height);
}
}
/*
* Now do the exposure if required.
*/
if (exposeflag)
GsDeliverExposureEvent(wp, x, y, width, height);
}
/* init buffered windows by allocating pixmap buffer and clearing background*/
void
GsInitWindowBuffer(GR_WINDOW *wp, GR_SIZE width, GR_SIZE height)
{
/* create same size RGBA pixmap for buffer*/
GR_WINDOW_ID id;
/* check if buffer size changed*/
if (wp->buffer) {
if (wp->width == width && wp->height == height)
return;
GsDestroyPixmap(wp->buffer);
}
id = GsNewPixmap(width, height, MWIF_RGBA8888, NULL);
wp->buffer = GsFindPixmap(id);
if (!wp->buffer) {
wp->props &= ~(GR_WM_PROPS_BUFFERED | GR_WM_PROPS_DRAWING_DONE);
return;
}
/* mark buffer as not ready for display*/
wp->props &= ~GR_WM_PROPS_DRAWING_DONE;
/* clear buffer to background color*/
if (!(wp->props & GR_WM_PROPS_NOBACKGROUND)) {
GR_PIXMAP *pp = wp->buffer;
/* clip to pixmap boundaries*/
#if DYNAMICREGIONS
GdSetClipRegion(pp->psd, GdAllocRectRegion(0, 0, pp->psd->xvirtres, pp->psd->yvirtres));
#else
MWCLIPRECT cliprect;
cliprect.x = 0;
cliprect.y = 0;
cliprect.width = pp->psd->xvirtres;
cliprect.height = pp->psd->yvirtres;
GdSetClipRects(pp->psd, 1, &cliprect);
#endif
clipwp = NULL; /* reset clip cache for next window draw*/
curgcp = NULL; /* invalidate gc cache since we're changing color and mode*/
GdSetFillMode(GR_FILL_SOLID);
GdSetMode(GR_MODE_COPY);
GdSetForegroundColor(pp->psd, wp->background);
GdFillRect(pp->psd, 0, 0, pp->width, pp->height);
}
}
/*
* Draw the border of a window if there is one.
* Note: To allow the border to be drawn with the correct clipping,
* we temporarily grow the size of the window to include the border.
*/
void
GsDrawBorder(GR_WINDOW *wp)
{
GR_COORD lminx; /* left edge minimum x */
GR_COORD rminx; /* right edge minimum x */
GR_COORD tminy; /* top edge minimum y */
GR_COORD bminy; /* bottom edge minimum y */
GR_COORD topy; /* top y value of window */
GR_COORD boty; /* bottom y value of window */
GR_SIZE width; /* original width of window */
GR_SIZE height; /* original height of window */
GR_SIZE bs; /* border size */
bs = wp->bordersize;
if (bs <= 0)
return;
width = wp->width;
height = wp->height;
lminx = wp->x - bs;
rminx = wp->x + width;
tminy = wp->y - bs;
bminy = wp->y + height;
topy = wp->y;
boty = bminy - 1;
wp->x -= bs;
wp->y -= bs;
wp->width += (bs * 2);
wp->height += (bs * 2);
wp->bordersize = 0;
clipwp = NULL;
/* FIXME: window clipregion will fail here */
GsSetClipWindow(wp, NULL, 0);
curgcp = NULL;
GdSetMode(GR_MODE_COPY);
GdSetForegroundColor(wp->psd, wp->bordercolor);
GdSetDash(0, 0);
GdSetFillMode(GR_FILL_SOLID);
if (bs == 1) {
GdLine(wp->psd, lminx, tminy, rminx, tminy, TRUE);
GdLine(wp->psd, lminx, bminy, rminx, bminy, TRUE);
GdLine(wp->psd, lminx, topy, lminx, boty, TRUE);
GdLine(wp->psd, rminx, topy, rminx, boty, TRUE);
} else {
GdFillRect(wp->psd, lminx, tminy, width + bs * 2, bs);
GdFillRect(wp->psd, lminx, bminy, width + bs * 2, bs);
GdFillRect(wp->psd, lminx, topy, bs, height);
GdFillRect(wp->psd, rminx, topy, bs, height);
}
/*
* Restore the true window size.
* Forget the currently clipped window since we messed it up.
*/
wp->x += bs;
wp->y += bs;
wp->width -= (bs * 2);
wp->height -= (bs * 2);
wp->bordersize = bs;
clipwp = NULL;
}
/*
* Clear the specified area of a window and possibly make an exposure event.
* This sets the area window to its background color or pixmap. If the
* exposeflag is 1, then this also creates an exposure event for the window.
* For buffered windows, mark drawing finalized and draw if
* exposeflag = 2.
*/
void
GsClearWindow(GR_WINDOW *wp, GR_COORD x, GR_COORD y, GR_SIZE width, GR_SIZE height, int exposeflag)
{
if (!wp->realized || !wp->output)
return;
/*
* Reduce the arguments so that they actually lie within the window.
*/
if (x < 0) {
width += x;
x = 0;
}
if (y < 0) {
height += y;
y = 0;
}
if (x + width > wp->width)
width = wp->width - x;
if (y + height > wp->height)
height = wp->height - y;
/*
* Now see if the region is really in the window. If not, then
* do nothing.
*/
if (x >= wp->width || y >= wp->height || width <= 0 || height <= 0)
return;
/*
* Buffered window drawing. First check if drawing finalized and
* set flag. Physical window background erase is never performed
* with buffered windows, all drawing is postponed until the application
* is finished by calling GrClearWindow(..., 2), ie. GrFlushWindow()
*/
if (exposeflag == 2)
wp->props |= GR_WM_PROPS_DRAWING_DONE;
if (wp->props & GR_WM_PROPS_BUFFERED) {
/* nothing to do until drawing finalized*/
if (!(wp->props & GR_WM_PROPS_DRAWING_DONE))
return;
/* prepare clipping to window boundaries*/
GsSetClipWindow(wp, NULL, 0);
clipwp = NULL; /* reset clip cache since no user regions used*/
#if DEBUG_EXPOSE
curgcp = NULL;
GdSetFillMode(GR_FILL_SOLID);
GdSetMode(GR_MODE_COPY);
GdSetForegroundColor(wp->psd, MWRGB(255,255,0)); /* yellow*/
GdFillRect(wp->psd, wp->x+x, wp->y+y, width, height);
usleep(500000);
#endif
/* copy window pixmap buffer to window*/
GdBlit(wp->psd, wp->x + x, wp->y + y, width, height, wp->buffer->psd, x, y, MWROP_COPY);
return; /* don't deliver exposure events*/
}
/*
* Unbuffered window: erase background unless nobackground flag set
*/
if (!(wp->props & GR_WM_PROPS_NOBACKGROUND)) {
/* perhaps find a better way of determining whether pixmap needs src_over*/
int hasalpha = wp->bgpixmap && (wp->bgpixmap->psd->data_format & MWIF_HASALPHA);
/*
* Draw the background of the window.
* Invalidate the current graphics context since
* we are changing the foreground color and mode.
*/
GsSetClipWindow(wp, NULL, 0);
clipwp = NULL; /* reset clip cache since no user regions used*/
#if DEBUG_EXPOSE
GdSetFillMode(GR_FILL_SOLID);
GdSetMode(GR_MODE_COPY);
GdSetForegroundColor(wp->psd, MWRGB(255,255,0)); /* yellow*/
GdFillRect(wp->psd, wp->x+x, wp->y+y, width, height);
usleep(500000);
#endif
curgcp = NULL;
GdSetFillMode(GR_FILL_SOLID);
GdSetMode(GR_MODE_COPY);
GdSetForegroundColor(wp->psd, wp->background);
/* if background pixmap w/alpha channel and stretchblit, fill entire (clipped) window*/
if (hasalpha && wp->bgpixmapflags == GR_BACKGROUND_STRETCH)
GdFillRect(wp->psd, wp->x, wp->y, wp->width, wp->height);
else /* if no pixmap background clear exposed area*/
if (!wp->bgpixmap || hasalpha) /* FIXME will flash with pixmap, should check src_over*/
if (!(wp->bgpixmapflags & GR_BACKGROUND_TRANS))
GdFillRect(wp->psd, wp->x + x, wp->y + y, width, height);
if (wp->bgpixmap)
GsDrawBackgroundPixmap(wp, wp->bgpixmap, x, y, width, height);
}
/*
* Do the exposure if required for unbuffered windows.
*/
if (exposeflag)
GsDeliverExposureEvent(wp, x, y, width, height);
}
/*
* Prepare to do drawing in a window or pixmap using the specified
* graphics context. Returns the drawable pointer if successful,
* and the type of drawing id that was supplied. Returns the special value
* GR_DRAW_TYPE_NONE if an error is generated, or if drawing is useless.
*/
GR_DRAW_TYPE
GsPrepareDrawing(GR_DRAW_ID id, GR_GC_ID gcid, GR_DRAWABLE **retdp)
{
GR_WINDOW *wp; /* found window */
GR_PIXMAP *pp; /* found pixmap */
GR_GC *gcp; /* found graphics context */
GR_REGION *regionp; /* user clipping region */
MWCLIPREGION*reg;
*retdp = NULL;
gcp = GsFindGC(gcid);
if (gcp == NULL)
return GR_DRAW_TYPE_NONE;
/*
* If the graphics context is not the current one, then
* make it the current one and remember to update it.
*/
if (gcp != curgcp) {
curgcp = gcp;
gcp->changed = GR_TRUE;
}
/*
* Look for window or pixmap id
*/
pp = NULL;
wp = GsFindWindow(id);
if (wp == NULL) {
pp = GsFindPixmap(id);
if (pp == NULL)
return GR_DRAW_TYPE_NONE;
havepixmap:
#if DYNAMICREGIONS
reg = GdAllocRectRegion(0, 0, pp->psd->xvirtres, pp->psd->yvirtres);
/* intersect with user region if any*/
if (gcp->regionid) {
regionp = GsFindRegion(gcp->regionid);
if (regionp) {
/* handle pixmap offsets*/
if (gcp->xoff || gcp->yoff) {
MWCLIPREGION *local = GdAllocRegion();
GdCopyRegion(local, regionp->rgn);
GdOffsetRegion(local, gcp->xoff, gcp->yoff);
GdIntersectRegion(reg, reg, local);
GdDestroyRegion(local);
} else
GdIntersectRegion(reg, reg, regionp->rgn);
}
}
GdSetClipRegion(pp->psd, reg);
#else
{
MWCLIPRECT cliprect;
/* FIXME: setup pixmap clipping, different from windows*/
cliprect.x = 0;
cliprect.y = 0;
cliprect.width = pp->psd->xvirtres;
cliprect.height = pp->psd->yvirtres;
GdSetClipRects(pp->psd, 1, &cliprect);
}
#endif
/* reset clip cache for next window draw*/
clipwp = NULL;
} else {
if (!wp->output) {
GsError(GR_ERROR_INPUT_ONLY_WINDOW, id);
return GR_DRAW_TYPE_NONE;
}
/* check if buffered window*/
if (wp->props & GR_WM_PROPS_BUFFERED) {
pp = wp->buffer;
wp = NULL;
goto havepixmap; /* draw into pixmap buffer*/
}
if (!wp->realized)
return GR_DRAW_TYPE_NONE;
/*
* If the window is not the currently clipped one,
* then make it the current one and define its clip rectangles.
*/
if (wp != clipwp || gcp->changed) {
#if DYNAMICREGIONS
/* find user region for intersect*/
regionp = gcp->regionid? GsFindRegion(gcp->regionid): NULL;
/* Special handling if user region is not at offset 0,0*/
if (regionp && (gcp->xoff || gcp->yoff)) {
MWCLIPREGION *local = GdAllocRegion();
GdCopyRegion(local, regionp->rgn);
GdOffsetRegion(local, gcp->xoff, gcp->yoff);
GsSetClipWindow(wp, local, gcp->mode & ~GR_MODE_DRAWMASK);
GdDestroyRegion(local);
} else
GsSetClipWindow(wp, regionp? regionp->rgn: NULL, gcp->mode & ~GR_MODE_DRAWMASK);
#else
GsSetClipWindow(wp, NULL, gcp->mode & ~GR_MODE_DRAWMASK);
#endif /* DYNAMICREGIONS*/
}
}
/*
* If the graphics context has been changed, then tell the
* device driver about it.
*/
if (gcp->changed) {
PSD psd = (wp ? wp->psd : pp->psd);
uint32_t mask;
int count;
if (gcp->linestyle == GR_LINE_SOLID) {
mask = 0;
count = 0;
} else {
mask = gcp->dashmask;
count = gcp->dashcount;
}
if (gcp->fgispixelval)
GdSetForegroundPixelVal(psd, gcp->foreground);
else
GdSetForegroundColor(psd, gcp->foreground);
if (gcp->bgispixelval)
GdSetBackgroundPixelVal(psd, gcp->background);
else
GdSetBackgroundColor(psd, gcp->background);
GdSetMode(gcp->mode & GR_MODE_DRAWMASK);
GdSetUseBackground(gcp->usebackground);
#if MW_FEATURE_SHAPES
GdSetDash(&mask, &count);
GdSetFillMode(gcp->fillmode);
GdSetTSOffset(gcp->ts_offset.x, gcp->ts_offset.y);
switch(gcp->fillmode) {
case GR_FILL_STIPPLE:
case GR_FILL_OPAQUE_STIPPLE:
GdSetStippleBitmap(gcp->stipple.bitmap, gcp->stipple.width, gcp->stipple.height);
break;
case GR_FILL_TILE:
GdSetTilePixmap(gcp->tile.psd, gcp->tile.width, gcp->tile.height);
break;
}
#endif
gcp->changed = GR_FALSE;
}
*retdp = wp? (GR_DRAWABLE *)wp: (GR_DRAWABLE *)pp;
return wp? GR_DRAW_TYPE_WINDOW: GR_DRAW_TYPE_PIXMAP;
}
/**
* Open low level graphics driver.
*
* @return The screen drawing surface.
*/
PSD
GdOpenScreen(void)
{
PSD psd;
MWPALENTRY * stdpal;
psd = scrdev.Open(&scrdev);
if (!psd)
return NULL;
/* assume no user changable palette entries*/
gr_firstuserpalentry = (int)psd->ncolors;
/* set palette according to system colors and devpalX.c*/
switch((int)psd->ncolors) {
#if !defined(NOSTDPAL1) /* don't require stdpal1 if not needed */
case 2: /* 1bpp*/
{
extern MWPALENTRY mwstdpal1[2];
stdpal = mwstdpal1;
}
break;
#endif
#if !defined(NOSTDPAL2) /* don't require stdpal2 if not needed */
case 4: /* 2bpp*/
{
extern MWPALENTRY mwstdpal2[4];
stdpal = mwstdpal2;
}
break;
#endif
#if !defined(NOSTDPAL4)
/* don't require stdpal4 if not needed */
case 8: /* 3bpp - not fully supported*/
case 16: /* 4bpp*/
{
extern MWPALENTRY mwstdpal4[16];
stdpal = mwstdpal4;
}
break;
#endif
#if !defined(NOSTDPAL8) /* don't require large stdpal8 if not needed */
case 256: /* 8bpp*/
{
extern MWPALENTRY mwstdpal8[256];
#if UNIFORMPALETTE
/* don't change uniform palette if alpha blending*/
gr_firstuserpalentry = 256;
#else
/* start after last system-reserved color*/
gr_firstuserpalentry = FIRSTUSERPALENTRY;
#endif
stdpal = mwstdpal8;
}
break;
#endif /* !defined(NOSTDPAL8)*/
default: /* truecolor*/
/* no palette*/
gr_firstuserpalentry = 0;
stdpal = NULL;
}
/* reset next user palette entry, write hardware palette*/
GdResetPalette();
GdSetPalette(psd, 0, (int)psd->ncolors, stdpal);
/* init local vars*/
GdSetMode(MWROP_COPY);
GdSetFillMode(MWFILL_SOLID); /* Set the fill mode to solid */
GdSetForegroundColor(psd, MWRGB(255, 255, 255)); /* WHITE*/
GdSetBackgroundColor(psd, MWRGB(0, 0, 0)); /* BLACK*/
GdSetUseBackground(TRUE);
/* select first builtin font (usually MWFONT_SYSTEM_VAR)*/
//GdSetFont(GdCreateFont(psd, NULL, 0, 0, NULL));
GdSetDash(0, 0); /* No dashing to start */
GdSetStippleBitmap(0,0,0); /* No stipple to start */
#if !NOCLIPPING
#if DYNAMICREGIONS
GdSetClipRegion(psd, GdAllocRectRegion(0, 0, psd->xvirtres, psd->yvirtres));
#else
GdSetClipRects(psd, 0, NULL);
#endif /* DYNAMICREGIONS*/
#endif /* NOCLIPPING*/
/* fill black (actually fill to first palette entry or truecolor 0*/
psd->FillRect(psd, 0, 0, psd->xvirtres-1, psd->yvirtres-1, 0);
return psd;
}
