BOOL WINAPI Ellipse(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect) { HWND hwnd; int rx, ry; RECT rc; hwnd = MwPrepareDC(hdc); if(!hwnd) return FALSE; SetRect(&rc, nLeftRect, nTopRect, nRightRect, nBottomRect); if(MwIsClientDC(hdc)) MapWindowPoints(hwnd, NULL, (LPPOINT)&rc, 2); rx = (rc.right - rc.left)/2 - 1; ry = (rc.bottom - rc.top)/2 - 1; rc.left += rx; rc.top += ry; /* fill ellipse in current brush color*/ if(hdc->brush->style != BS_NULL) { InflateRect(&rc, -1, -1); GdSetForegroundColor(hdc->psd, hdc->brush->color); GdEllipse(hdc->psd, rc.left, rc.top, rx, ry, TRUE); } /* draw ellipse outline in current pen color*/ if(hdc->pen->style != PS_NULL) { GdSetForegroundColor(hdc->psd, hdc->pen->color); GdEllipse(hdc->psd, rc.left, rc.top, rx, ry, FALSE); } return TRUE; }
BOOL WINAPI Rectangle(HDC hdc, int nLeft, int nTop, int nRight, int nBottom) { HWND hwnd; RECT rc; hwnd = MwPrepareDC(hdc); if(!hwnd) return FALSE; SetRect(&rc, nLeft, nTop, nRight, nBottom); if(MwIsClientDC(hdc)) MapWindowPoints(hwnd, NULL, (LPPOINT)&rc, 2); /* draw rectangle in current pen color*/ if(hdc->pen->style != PS_NULL) { GdSetForegroundColor(hdc->psd, hdc->pen->color); GdRect(hdc->psd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top); } /* fill rectangle in current brush color*/ if(hdc->brush->style != BS_NULL) { InflateRect(&rc, -1, -1); GdSetForegroundColor(hdc->psd, hdc->brush->color); GdFillRect(hdc->psd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top); } return TRUE; }
void polyfill(int n, vec2 points[]) { int i; int xoff, yoff; MWPOINT pv[MAXPOLY]; if(!hdc) return; /* calc window offset*/ xoff = hdc->hwnd->clirect.left; yoff = hdc->hwnd->clirect.top; /* only plot non-trivial polygons*/ if(n > 2) { for(i=0; i<n; ++i) { pv[i].x = fx(points[i].x) + xoff; pv[i].y = fy(points[i].y) + yoff; /* fix: floating round error, y intercept difference * with GdLine */ /*pv[i].x = fx(points[i].x + xoff);*/ /*pv[i].y = fy(points[i].y + yoff);*/ } GdSetForegroundColor(hdc->psd, hdc->pen->color); GdFillPoly(hdc->psd, n, pv); } }
/* draw line segments by connecting passed points*/ BOOL WINAPI Polyline(HDC hdc, CONST POINT *lppt, int cPoints) { HWND hwnd; POINT beg, end; if(cPoints <= 1) return FALSE; hwnd = MwPrepareDC(hdc); if(!hwnd) return FALSE; if(hdc->pen->style == PS_NULL) return TRUE; /* draw line in current pen color*/ GdSetForegroundColor(hdc->psd, hdc->pen->color); beg = *lppt++; if(MwIsClientDC(hdc)) ClientToScreen(hwnd, &beg); while(--cPoints > 0) { end = *lppt++; if(MwIsClientDC(hdc)) ClientToScreen(hwnd, &end); /* don't draw last point*/ GdLine(hdc->psd, beg.x, beg.y, end.x, end.y, FALSE); beg = end; } return TRUE; }
BOOL WINAPI LineTo(HDC hdc, int x, int y) { HWND hwnd; POINT beg, end; hwnd = MwPrepareDC(hdc); if(!hwnd) return FALSE; beg.x = hdc->pt.x; beg.y = hdc->pt.y; end.x = x; end.y = y; if(MwIsClientDC(hdc)) { ClientToScreen(hwnd, &beg); ClientToScreen(hwnd, &end); } /* draw line in current pen color*/ if(hdc->pen->style != PS_NULL) { GdSetForegroundColor(hdc->psd, hdc->pen->color); /* don't draw last point*/ GdLine(hdc->psd, beg.x, beg.y, end.x, end.y, FALSE); } hdc->pt.x = x; hdc->pt.y = y; return TRUE; }
/* * 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); }
static void dopiearc(HDC hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect, int ax, int ay, int bx, int by, int type) { HWND hwnd; int rx, ry; RECT rc, rc2; hwnd = MwPrepareDC(hdc); if(!hwnd) return; SetRect(&rc, nLeftRect, nTopRect, nRightRect, nBottomRect); SetRect(&rc2, ax, ay, bx, by); if(MwIsClientDC(hdc)) { MapWindowPoints(hwnd, NULL, (LPPOINT)&rc, 2); MapWindowPoints(hwnd, NULL, (LPPOINT)&rc2, 2); } rx = (rc.right - rc.left)/2 - 1; ry = (rc.bottom - rc.top)/2 - 1; rc.left += rx; rc.top += ry; /* fill ellipse in current brush color*/ if(hdc->brush->style != BS_NULL && type == MWPIE) { GdSetForegroundColor(hdc->psd, hdc->brush->color); GdArc(hdc->psd, rc.left, rc.top, rx, ry, rc2.left, rc2.top, rc2.right, rc2.bottom, MWPIE); } /* draw ellipse outline in current pen color*/ if(hdc->pen->style != PS_NULL) { GdSetForegroundColor(hdc->psd, hdc->pen->color); if(type == MWPIE) type = MWARC; /* MWARCOUTLINE?*/ GdArc(hdc->psd, rc.left, rc.top, rx, ry, rc2.left, rc2.top, rc2.right, rc2.bottom, type); } }
BOOL WINAPI Polygon(HDC hdc, CONST POINT *lpPoints, int nCount) { HWND hwnd; int i; LPPOINT pp, ppAlloc = NULL; hwnd = MwPrepareDC(hdc); if(!hwnd) return FALSE; if(MwIsClientDC(hdc)) { /* convert points to client coords*/ ppAlloc = (LPPOINT)malloc(nCount * sizeof(POINT)); if(!ppAlloc) return FALSE; memcpy(ppAlloc, lpPoints, nCount*sizeof(POINT)); pp = ppAlloc; for(i=0; i<nCount; ++i) ClientToScreen(hwnd, pp++); pp = ppAlloc; } else pp = (LPPOINT)lpPoints; /* fill polygon in current brush color*/ if(hdc->brush->style != BS_NULL) { GdSetForegroundColor(hdc->psd, hdc->brush->color); GdFillPoly(hdc->psd, nCount, pp); } /* draw polygon outline in current pen color*/ if(hdc->pen->style != PS_NULL) { GdSetForegroundColor(hdc->psd, hdc->pen->color); GdPoly(hdc->psd, nCount, pp); } if(ppAlloc) free(ppAlloc); return TRUE; }
/* 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); } }
COLORREF WINAPI SetPixel(HDC hdc, int x, int y, COLORREF crColor) { HWND hwnd; POINT pt; hwnd = MwPrepareDC(hdc); if(!hwnd) return 0; /* doesn't return previous color*/ pt.x = x; pt.y = y; if(MwIsClientDC(hdc)) ClientToScreen(hwnd, &pt); /* draw point in passed color*/ GdSetForegroundColor(hdc->psd, crColor); GdPoint(hdc->psd, pt.x, pt.y); return 0; /* doesn't return previous color*/ }
int WINAPI FillRect(HDC hdc, CONST RECT *lprc, HBRUSH hbr) { HWND hwnd; RECT rc; MWBRUSHOBJ * obr = (MWBRUSHOBJ *)hbr; COLORREF crFill; hwnd = MwPrepareDC(hdc); if(!hwnd || !obr) return FALSE; if(!lprc) { if(MwIsClientDC(hdc)) GetClientRect(hwnd, &rc); else GetWindowRect(hwnd, &rc); lprc = &rc; } else rc = *lprc; if(MwIsClientDC(hdc)) MapWindowPoints(hwnd, NULL, (LPPOINT)&rc, 2); /* handle COLOR_xxx + 1 passed as HBRUSH*/ if((intptr_t)obr <= MAXSYSCOLORS) crFill = GetSysColor((intptr_t)obr-1); else { /* get color from passed HBRUSH*/ if(obr->style == BS_NULL) return TRUE; crFill = obr->color; } /* fill rectangle in passed brush color*/ GdSetForegroundColor(hdc->psd, crFill); GdFillRect(hdc->psd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top); return TRUE; }
/* * 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; }
/* internal version of ExtTextOut, passed flags for text data type*/ static BOOL MwExtTextOut(HDC hdc, int x, int y, UINT fuOptions, CONST RECT *lprc, LPCVOID lpszString, UINT cbCount, CONST INT *lpDx, int flags) { HWND hwnd; POINT pt; RECT rc; hwnd = MwPrepareDC(hdc); if(!hwnd) return FALSE; pt.x = x; pt.y = y; if(MwIsClientDC(hdc)) ClientToScreen(hwnd, &pt); /* optionally fill passed rectangle*/ if(lprc && (fuOptions&ETO_OPAQUE)) { rc = *lprc; if(MwIsClientDC(hdc)) MapWindowPoints(hwnd, NULL, (LPPOINT)&rc, 2); /* fill rectangle with current background color*/ GdSetForegroundColor(hdc->psd, hdc->bkcolor); GdFillRect(hdc->psd, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top); GdSetUseBackground(FALSE); } else { /* use current background mode for text background draw*/ GdSetUseBackground(hdc->bkmode == OPAQUE? TRUE: FALSE); /* always set background color in case GdArea is * used to draw, which compares gr_foreground != gr_background * if gr_usebg is false... */ /*if(hdc->bkmode == OPAQUE)*/ GdSetBackgroundColor(hdc->psd, hdc->bkcolor); } if (cbCount == 0) { /* Special case - no text. Used to fill rectangle. */ return TRUE; } /* nyi: lpDx*/ /* draw text in current text foreground and background color*/ GdSetForegroundColor(hdc->psd, hdc->textcolor); //GdSetFont(hdc->font->pfont); /* this whole text alignment thing needs rewriting*/ if((hdc->textalign & TA_BASELINE) == TA_BASELINE) { /* this is not right... changed for kaffe port flags |= MWTF_TOP; */ flags |= MWTF_BASELINE; } else if(hdc->textalign & TA_BOTTOM) { MWCOORD ph, pw, pb; if(lprc) pt.y += lprc->bottom - lprc->top; else { GdGetTextSize(hdc->font->pfont, lpszString, cbCount, &pw, &ph, &pb, flags); pt.y += ph; } flags |= MWTF_BOTTOM; } else flags |= MWTF_TOP; if((hdc->textalign & TA_CENTER) == TA_CENTER) { MWCOORD ph, pw, pb; GdGetTextSize(hdc->font->pfont, lpszString, cbCount, &pw, &ph, &pb, flags); pt.x -= pw/2; } else if(hdc->textalign & TA_RIGHT) { MWCOORD ph, pw, pb; GdGetTextSize(hdc->font->pfont, lpszString, cbCount, &pw, &ph, &pb, flags); pt.x -= pw; } GdText(hdc->psd, hdc->font->pfont, pt.x, pt.y, lpszString, cbCount, flags); return TRUE; }
/** * 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; }