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);
GdSetForeground(GdFindColor(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) {
GdSetForeground(GdFindColor(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) {
GdSetForeground(GdFindColor(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);
GdSetForeground(GdFindColor(hdc->brush->color));
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;
GsSetClipWindow(wp, NULL, 0);
curgcp = NULL;
GdSetMode(GR_MODE_COPY);
GdSetForeground(GdFindColor(wp->bordercolor));
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;
}
/* 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*/
GdSetForeground(GdFindColor(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) {
GdSetForeground(GdFindColor(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->unmapcount || !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;
if (!(wp->props & GR_WM_PROPS_NOBACKGROUND)) {
GdSetMode(GR_MODE_COPY);
GdSetForeground(GdFindColor(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) {
GdSetForeground(GdFindColor(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) {
GdSetForeground(GdFindColor(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) {
GdSetForeground(GdFindColor(hdc->brush->color));
GdFillPoly(hdc->psd, nCount, pp);
}
/* draw polygon outline in current pen color*/
if(hdc->pen->style != PS_NULL) {
GdSetForeground(GdFindColor(hdc->pen->color));
GdPoly(hdc->psd, nCount, pp);
}
if(ppAlloc)
free(ppAlloc);
return TRUE;
}
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*/
GdSetForeground(GdFindColor(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((PTRTOINT)obr <= MAXSYSCOLORS)
crFill = GetSysColor((int)obr-1);
else {
/* get color from passed HBRUSH*/
if(obr->style == BS_NULL)
return TRUE;
crFill = obr->color;
}
/* fill rectangle in passed brush color*/
GdSetForeground(GdFindColor(crFill));
GdFillRect(hdc->psd, rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top);
return TRUE;
}
/*
* 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_FONT *fontp;
GR_REGION *regionp; /* user clipping region */
MWCLIPREGION *reg;
PMWFONT pf;
*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;
#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)
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;
}
if (wp->unmapcount)
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) {
/* find user region for intersect*/
if (gcp->regionid)
regionp = GsFindRegion(gcp->regionid);
else regionp = 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);
}
}
}
/*
* If the graphics context has been changed, then tell the
* device driver about it.
*/
if (gcp->changed) {
GdSetForeground(GdFindColor(gcp->foreground));
GdSetBackground(GdFindColor(gcp->background));
GdSetMode(gcp->mode & GR_MODE_DRAWMASK);
GdSetUseBackground(gcp->usebackground);
fontp = GsFindFont(gcp->fontid);
pf = fontp? fontp->pfont: stdfont;
GdSetFont(pf);
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
*/
PSD
GdOpenScreen(void)
{
PSD psd;
MWPALENTRY * stdpal;
MWSCREENINFO sinfo;
psd = scrdev.Open(&scrdev);
if (!psd)
return NULL;
GdGetScreenInfo(psd, &sinfo);
gr_pixtype = sinfo.pixtype;
gr_ncolors = sinfo.ncolors;
/* 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 xxxALPHABLEND
/* 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);
#if xxxALPHABLEND
/* one-time create alpha lookup table for 8bpp systems (takes ~1 sec)*/
if(psd->ncolors == 256)
init_alpha_lookup();
#endif
#if !NOFONTSORCLIPPING
/* init local vars*/
GdSetMode(MWMODE_COPY);
GdSetForeground(GdFindColor(MWRGB(255, 255, 255))); /* WHITE*/
GdSetBackground(GdFindColor(MWRGB(0, 0, 0))); /* BLACK*/
GdSetUseBackground(TRUE);
GdSetFont(GdCreateFont(psd, MWFONT_SYSTEM_VAR, 0, NULL));
#if DYNAMICREGIONS
GdSetClipRegion(psd,
GdAllocRectRegion(0, 0, psd->xvirtres, psd->yvirtres));
#else
GdSetClipRects(psd, 0, NULL);
#endif /* DYNAMICREGIONS*/
#endif /* NOFONTSORCLIPPING*/
/* 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;
}
LRESULT CALLBACK
WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
PAINTSTRUCT ps;
HDC hdc;
#if CLIENT3D | IMAGE | GRAPH3D
RECT rc;
#endif
#if GRAPH3D
static int countup = 1;
int id;
static vec1 gx, gy;
#endif
#if TIMERDEMO
static POINT mousept;
#endif
#if ARCDEMO
static int startdegrees = 0;
static int enddegrees = 30;
#endif
switch( msg) {
#if TIMERDEMO
case WM_CREATE:
SetTimer(hwnd, 1, 100, NULL);
mousept.x = 60;
mousept.y = 20;
break;
case WM_TIMER:
#if GRAPH3D
GetClientRect(hwnd, &rc);
if(countup) {
mousept.y += 20;
if(mousept.y >= rc.bottom) {
mousept.y -= 20;
countup = 0;
}
} else {
mousept.y -= 20;
if(mousept.y < 20) {
mousept.y += 20;
countup = 1;
}
}
SendMessage(hwnd, WM_MOUSEMOVE, 0,
MAKELONG(mousept.x, mousept.y));
#endif
#if ARCDEMO
startdegrees += 10;
if(startdegrees >= 360)
startdegrees = 0;
enddegrees += 15;
if(enddegrees >= 360)
enddegrees = 0;
InvalidateRect(hwnd, NULL, TRUE);
#endif
break;
case WM_DESTROY:
KillTimer(hwnd, 1);
break;
#endif /* TIMERDEMO*/
case WM_SIZE:
break;
case WM_MOVE:
break;
#if CLIENT3D
case WM_SETFOCUS:
PostMessage((HWND)wp, WM_PAINT, 0, 0L);
break;
case WM_KILLFOCUS:
PostMessage((HWND)wp, WM_PAINT, 0, 0L);
break;
case WM_ERASEBKGND:
if(GetFocus() != hwnd)
return DefWindowProc(hwnd, msg, wp, lp);
return 1;
#endif
#if GRAPH3D
case WM_ERASEBKGND:
if((GetWindowLong(hwnd, GWL_ID) & 03) == 1)
return 1;
return DefWindowProc(hwnd, msg, wp, lp);
#endif
case WM_PAINT:
hdc = BeginPaint(hwnd, &ps);
#if CLIENT3D
if(GetFocus() == hwnd) {
GetClientRect(hwnd, &rc);
Draw3dShadow(hdc, rc.left, rc.top,
rc.right-rc.left, rc.bottom-rc.top,
GetSysColor(COLOR_3DDKSHADOW),
GetSysColor(COLOR_3DLIGHT));
InflateRect(&rc, -1, -1);
FillRect(hdc, &rc, GetStockObject(GRAY_BRUSH));
}
#endif
#if IMAGE
GetClientRect(hwnd, &rc);
DrawDIB(hdc, rc.left+2, rc.top+2, image2);
#endif
#if ARCDEMO
{
int x, y, w, h;
RECT rc;
if(hdc != NULL) {
GetWindowRect(hwnd, &rc);
rc.top += 13;
InflateRect(&rc, -3, -3);
/*Ellipse(hdc, 0, 0, rc.right-rc.left, rc.bottom-rc.top);*/
/*Arc(hdc, 0, 0, rc.right-rc.left, rc.bottom-rc.top, 0,0, 0,0);*/
/*Pie(hdc, 0, 0, rc.right-rc.left, rc.bottom-rc.top, 0,0, 0,0);*/
x = rc.left;
y = rc.top;
w = rc.right - rc.left;
h = rc.bottom - rc.top;
w += 10;
GdSetForeground(GdFindColor(RGB(0,255,0)));
GdArcAngle(hdc->psd, x+w/2, y+h/2, w/2, h/2, startdegrees*64,
enddegrees*64, MWPIE);
GdSetForeground(GdFindColor(RGB(0,0,0)));
GdArcAngle(hdc->psd, x+w/2, y+h/2, w/2, h/2, startdegrees*64,
enddegrees*64, MWARCOUTLINE);
/*GdSetForeground(GdFindColor(RGB(255,255,255)));*/
/*GdPoint(hdc->psd, x+w/2, y+h/2);*/
}
EndPaint(hwnd, &ps);
break;
}
#endif /* ARCDEMO*/
#if GRAPH3D
id = (int)GetWindowLong(hwnd, GWL_ID) & 03;
init3(hdc, id == 1? hwnd: NULL);
switch(id) {
case 0:
rose(1.0, 7, 13);
break;
case 1:
/*look3(0.5, 0.7, 1.5);*/
/*look3(0.2, -2 * gy, 1.0+gx);*/
look3(-2 * gx, -2 * gy, 1.2);
drawgrid(-8.0, 8.0, 10, -8.0, 8.0, 10);
break;
case 2:
setcolor3(BLACK);
circle3(1.0);
break;
case 3:
setcolor3(BLUE);
daisy(1.0, 20);
break;
}
#if CLIPDEMO
if(id == 1) {
HRGN hrgn, hrgn2;
/* create circular clip region for effect*/
GetClientRect(hwnd, &rc);
InflateRect(&rc, -80, -80);
switch((int)GetWindowLong(hwnd, GWL_ID)) {
default:
hrgn = CreateEllipticRgnIndirect(&rc);
break;
case 5:
hrgn = CreateRoundRectRgn(rc.left, rc.top,
rc.right, rc.bottom, 100, 100);
break;
case 1:
hrgn = CreateRectRgnIndirect(&rc);
break;
}
/* erase background, clip out blit area*/
GetClientRect(hwnd, &rc);
hrgn2 = CreateRectRgnIndirect(&rc);
SelectClipRgn(hdc, hrgn2);
ExtSelectClipRgn(hdc, hrgn, RGN_XOR);
DeleteObject(hrgn2);
GetClientRect(hwnd, &rc);
FillRect(hdc, &rc, GetStockObject(BLACK_BRUSH));
/* clip in only blit area*/
SelectClipRgn(hdc, hrgn);
DeleteObject(hrgn);
}
#endif /* CLIPDEMO*/
paint3(hdc);
#endif /* GRAPH3D*/
EndPaint(hwnd, &ps);
break;
case WM_LBUTTONDOWN:
break;
case WM_MOUSEMOVE:
#if GRAPH3D
if((GetWindowLong(hwnd, GWL_ID) & 03) == 1) {
POINT pt;
POINTSTOPOINT(pt, lp);
GetClientRect(hwnd, &rc);
gx = (vec1)pt.x / rc.right;
gy = (vec1)pt.y / rc.bottom;
InvalidateRect(hwnd, NULL, FALSE);
mousept.x = pt.x;
mousept.y = pt.y;
}
#endif
break;
case WM_LBUTTONUP:
break;
case WM_RBUTTONDOWN:
break;
default:
return DefWindowProc( hwnd, msg, wp, lp);
}
return( 0);
}
/* 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*/
GdSetForeground(GdFindColor(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)*/
GdSetBackground(GdFindColor(hdc->bkcolor));
}
/* nyi: lpDx*/
/* draw text in current text foreground and background color*/
GdSetForeground(GdFindColor(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;
GdText(hdc->psd, pt.x, pt.y, lpszString, cbCount, flags);
return TRUE;
}
