The R Project SVN – R – Diff – /trunk/src/gnuwin32/graphapp/gdraw.c


/*
 *  R : A Computer Language for Statistical Data Analysis
 *  Copyright (C) 1998--2001  Guido Masarotto and Brian Ripley
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
/*
   A version of drawing.c without current/state.
   More safe in case of multiple redrawing
 */
 
#include "internal.h"
#include <winbase.h>
 
static HDC GETHDC(drawing d)
{
  if (!d)
  {
      DebugBreak();
      return (HDC) 0; /* We should never get here, but we do? */
  }
  if ( (d->kind == PrinterObject)|| (d->kind == MetafileObject))
  {
     HDC dc = (HDC) d->handle ;
     SelectObject(dc, GetStockObject(NULL_PEN));
     SelectObject(dc, GetStockObject(NULL_BRUSH));
     return dc ;
  }
  else
     return get_context(d);
}
 
 
/*
 *  Some clipping functions.
 */
rect ggetcliprect(drawing d)
{
    RECT R;
    rect r;
    HDC dc = GETHDC(d);
    GetClipBox(dc, &R);
    r.x = R.left;
    r.y = R.top;
    r.width = R.right - R.left;
    r.height = R.bottom - R.top;
    return r;
}
 
void gsetcliprect(drawing d, rect r)
{
    HRGN rgn;
    HDC dc = GETHDC(d);
    rgn = CreateRectRgn(r.x, r.y, r.x + r.width, r.y + r.height);
    SelectClipRgn(dc, rgn);
    DeleteObject(rgn);
}
 
 
void gbitblt(drawing db, drawing sb, point p, rect r)
{
    HDC src;
    HDC dst;
 
    dst = GETHDC(db);
    src = GETHDC(sb);
    BitBlt(dst, p.x, p.y, r.width, r.height, src, r.x, r.y, SRCCOPY);
}
 
 
 
/* dp gives the amount to scroll; r the full rectangle to scroll */
void gscroll(drawing d, point dp, rect r)
{
    HDC dc = GETHDC(d);
    RECT rr ;
    rr.left = r.x;
    rr.top = r.y;
    rr.right = r.x + r.width;
    rr.bottom = r.y + r.height;
    ScrollDC(dc, dp.x , dp.y , &rr, &rr, 0, NULL);
}
 
void ginvert(drawing d, rect r)
{
    HDC dc = GETHDC(d);
 
    PatBlt(dc, r.x, r.y, r.width, r.height, DSTINVERT);
}
 
rgb ggetpixel(drawing d, point p)
{
    rgb c;
    HDC dc = GETHDC(d);
 
    c = GetPixel(dc, p.x, p.y);
    c = ((c&0x000000FFL)<<16) | (c&0x0000FF00L) |
	((c&0x00FF0000L)>>16);
    return c;
}
 
static COLORREF getwinrgb(drawing d, rgb c)
{
    int r, g, b;
    long luminance;
    int depth;
 
    r = (int) ((c >> 16) & 0x000000FFL);
    g = (int) ((c >>  8) & 0x000000FFL);
    b = (int) ((c >>  0) & 0x000000FFL);
    depth = getdepth(d);
    if (depth <= 2)	/* map to black or white, or grey if c == Grey */
    {
	luminance = (r*3 + g*5 + b) / 9;
	if (luminance > 0x0087)		r = g = b = 0x00FF;
	else if (luminance <= 0x0077)	r = g = b = 0x0000;
	else				r = g = b = 0x0080;
	c = rgb(r, g, b);
    }
    return RGB(r, g, b);
}
 
void gsetpixel(drawing d, point p, rgb c)
{
    HDC dc = GETHDC(d);
    HBRUSH br = CreateSolidBrush(getwinrgb(d, c));
 
    fix_brush(dc, d, br);
    SelectObject(dc, br);
    PatBlt(dc, p.x, p.y, 1, 1, PATCOPY);
    SelectObject(dc, GetStockObject(NULL_BRUSH));
    DeleteObject(br);
}
 
typedef struct {
    HDC dc;
    int len2; /* squared length of current dash */
    int curseg, on; /* current dash (0-7), on/off flag */
    int style, width;
    int curx, cury; /* start of current dash */
} DashStruct;
 
static int npieces;
 
static void CALLBACK  gLineHelper(int x, int y, LPARAM aa)
{
    DashStruct *a = (DashStruct *) aa;
    int distx, disty;
 
    npieces++;
    distx = x - (a->curx);
    disty = y - (a->cury);
    if (distx*distx + disty*disty >= (a->len2)) {
	if (a->on)
	    LineTo(a->dc, x, y);
	else
	    MoveToEx(a->dc, x, y, NULL);
	a->curx = x;
	a->cury = y;
	a->len2 = 0;
	while (!a->len2) {
	    a->curseg = (a->curseg + 4) % 32;
	    a->len2 = (((a->style) >> (a->curseg)) & 15) * (a->width);
	    a->len2 = (a->len2) * (a->len2);
	    a->on = (a->on) ? 0 : 1;
	}
    }
}
 
void gdrawline(drawing d, int width, int style, rgb c, point p1, point p2,
	       int fast)
{
   point p[2];
   p[0] = p1;
   p[1] = p2;
   gdrawpolyline( d, width, style, c, p, 2, 0, fast);
}
 
void gdrawpolyline(drawing d, int width, int style, rgb c,
                   point p[], int n, int closepath, int fast)
{
    int tmpx, tmpy, tmp;
    HDC dc = GETHDC(d);
    COLORREF winrgb = getwinrgb(d, c);
    LOGBRUSH lb;
    HPEN gpen;
    int i;
 
    if (n < 2) return;
    lb.lbStyle = BS_SOLID;
    lb.lbColor = winrgb;
    lb.lbHatch = 0;
    if (!style) {
	if (fast)
	    gpen = CreatePen(PS_INSIDEFRAME, width, winrgb);
	else
	    gpen = ExtCreatePen(PS_GEOMETRIC|PS_SOLID|PS_ENDCAP_FLAT|PS_JOIN_ROUND,
				width, &lb, 0, NULL);
	SelectObject(dc, gpen);
	SetROP2(dc, R2_COPYPEN);
        MoveToEx(dc, p[0].x, p[0].y, NULL);
        for (i = 1; i < n ; i++)
	      LineTo(dc, p[i].x, p[i].y);
        if (closepath) LineTo(dc, p[0].x, p[0].y);
	SelectObject(dc, GetStockObject(NULL_PEN));
	DeleteObject(gpen);
    }
     else {
	DashStruct a;
	gpen = ExtCreatePen(PS_GEOMETRIC|PS_SOLID|PS_ENDCAP_FLAT|PS_JOIN_ROUND,
			    width, &lb, 0, NULL);
	SelectObject(dc, gpen);
	SetROP2(dc, R2_COPYPEN);
	a.on = 1;
	a.dc = dc;
	a.len2 = (style & 15) * width;
	a.len2 = (a.len2) * (a.len2);
	a.curseg = 0;
	a.style = style;
	a.width = width;
	a.curx = p[0].x;
	a.cury = p[0].y;
	MoveToEx(dc, p[0].x, p[0].y, NULL);
	npieces = 0;
	BeginPath(dc);
        for (i = 1; i < n; i++) {
 	  LineDDA(p[i-1].x, p[i-1].y, p[i].x, p[i].y, gLineHelper,
		  (LPARAM) &a);
	  if ((p[i].x != a.curx) || (p[i].y != a.cury)) {
	      if (a.on) LineTo(dc, p[i].x, p[i].y);
	      else MoveToEx(dc, p[i].x, p[i].y, NULL);
	      tmpx = (a.curx-p[i].x);
	      tmpy = (a.cury-p[i].y);
	      tmp = tmpx*tmpx + tmpy*tmpy;
	      a.len2 = a.len2 + tmp - 2*sqrt((double)(tmp*a.len2));
	      a.curx = p[i].x;
	      a.cury = p[i].y;
	  }
	  if(npieces > 5000) {
	      EndPath(dc);
	      StrokePath(dc);
	      npieces = 0;
	      BeginPath(dc);
	  }
        }
        if (closepath) {
          LineDDA(p[n-1].x, p[n-1].y, p[0].x, p[0].y, gLineHelper,
		  (LPARAM) &a);
	  if (a.on) LineTo(dc,p[0].x,p[0].y);
        }
	EndPath(dc);
	StrokePath(dc);
	SelectObject(dc, GetStockObject(NULL_PEN));
	DeleteObject(gpen);
    }
}
 
void gdrawrect(drawing d, int width, int style, rgb c, rect r, int fast)
{
    int x0 = r.x;
    int y0 = r.y;
    int x1 = r.x + r.width;
    int y1 = r.y + r.height;
    point p[4];
    p[0] = pt(x0,y0);
    p[1] = pt(x1,y0);
    p[2] = pt(x1,y1);
    p[3] = pt(x0,y1);
    gdrawpolyline(d, width, style, c, p, 4, 1, fast);
}
 
void gfillrect(drawing d, rgb fill, rect r)
{
    HDC dc = GETHDC(d);
    HBRUSH br = CreateSolidBrush(getwinrgb(d, fill));
    fix_brush(dc, d, br);
    SelectObject(dc, br);
    PatBlt(dc, r.x, r.y, r.width, r.height, PATCOPY);
    SelectObject(dc, GetStockObject(NULL_BRUSH));
    DeleteObject(br);
}
 
void gdrawellipse(drawing d, int width, rgb border, rect r, int fast)
{
    HDC dc = GETHDC(d);
    LOGBRUSH lb;
    HPEN gpen;
    if (fast)
	gpen = CreatePen(PS_INSIDEFRAME, width, getwinrgb(d, border));
    else {
	lb.lbStyle = BS_SOLID;
	lb.lbColor = getwinrgb(d, border);
	lb.lbHatch = 0;
	gpen = ExtCreatePen(PS_GEOMETRIC|PS_SOLID|PS_ENDCAP_FLAT|PS_JOIN_ROUND,
			    width, &lb, 0, NULL);
    }
    SelectObject(dc, gpen);
    SetROP2(dc, R2_COPYPEN);
    Ellipse(dc, r.x, r.y, r.x+r.width, r.y+r.height);
    SelectObject(dc, GetStockObject(NULL_PEN));
    DeleteObject(gpen);
}
 
void goldfillellipse(drawing d, rgb fill, rect r)
{
    HDC dc = GETHDC(d);
    HBRUSH br = CreateSolidBrush(getwinrgb(d, fill));
    fix_brush(dc, d, br);
    SelectObject(dc, br);
    Ellipse(dc, r.x, r.y, r.x+r.width, r.y+r.height);
    SelectObject(dc, GetStockObject(NULL_BRUSH));
    DeleteObject(br);
}
 
 
#ifndef fastfillrect
#define fastfillrect(x, y, w, h) PatBlt(dc, (x), (y), (w), (h), mode)
#endif
 
void gfillellipse(drawing d, rgb fill, rect r)
{			/* e(x,y) = b*b*x*x + a*a*y*y - a*a*b*b */
    register long mode = PATCOPY;
    int w_odd = (r.width & 0x0001);
    int h_odd = (r.height & 0x0001);
    int a = r.width >> 1;
    int b = r.height >> 1;
    point c = pt(r.x+a,r.y+b);
    int x = 0;
    int y = b;
    long a2 = a*a;
    long b2 = b*b;
    long xcrit = ((a2+a2+a2) >> 2) + 1;
    long ycrit = ((b2+b2+b2) >> 2) + 1;
    long t = b2 + a2 - (a2+a2)*b;	/* t = e(x+1,y-1) */
    long dxt = b2*(3+x+x);
    long dyt = a2*(3-y-y);
    int d2xt = b2+b2;
    int d2yt = a2+a2;
    int stored = 0;
    int sx = 0, sy = 0, sh = 0; /* stored values of x, y, height */
    HDC dc;
    HBRUSH br;
 
    if ((r.width > 31) && (r.height > 31)) {
	goldfillellipse(d, fill, r);
	return;
    }
    if ((r.width < 3) || (r.height < 3)) {
	gfillrect(d, fill, r);
	return;
    }
    dc = GETHDC(d);
    br = CreateSolidBrush(getwinrgb(d, fill));
    fix_brush(dc, d, br);
    SelectObject(dc, br);
 
    if (w_odd == 0) {
	fastfillrect(c.x-1,c.y-b,2,r.height);
    }
 
    while (y > 0) {
	if (stored) {
	    if (sx != x) { /* output stored rect */
		fastfillrect(c.x-sx,c.y-sy, sx+sx+w_odd,sh);
		fastfillrect(c.x-sx,c.y+sy+h_odd-sh, sx+sx+w_odd,sh);
		stored = 0;
	    }
	    else /* increment height of stored rect */
		sh++;
	}
	if (t + a2*y < xcrit) { /* e(x+1,y-1/2) <= 0 */
	    /* move left and right to encounter edge */
	    x += 1;
	    t += dxt;
	    dxt += d2xt;
	} else if (t - b2*x >= ycrit) { /* e(x+1/2,y-1) > 0 */
	    /* drop down one line */
	    if (!stored) {
		sx = x;
		sy = y;
		sh = 1;
		stored = 1;
	    }
	    y -= 1;
	    t += dyt;
	    dyt += d2yt;
	} else {
	    /* drop diagonally down and out */
	    if (!stored) {
		sx = x;
		sy = y;
		sh = 1;
		stored = 1;
	    }
 
	    x += 1;
	    y -= 1;
	    t += dxt + dyt;
	    dxt += d2xt;
	    dyt += d2yt;
	}
    }
    if (stored) { /* output stored rectangle */
	fastfillrect(c.x-sx, c.y-sy, sx+sx+w_odd, sh);
	fastfillrect(c.x-sx, c.y+sy+h_odd-sh, sx+sx+w_odd, sh);
	stored = 0;
    }
    if (x <= a){
	fastfillrect(c.x-a, c.y-y, a+a+w_odd, 1);
	fastfillrect(c.x-a, c.y+y-1+h_odd, a+a+w_odd, 1);
    }
    SelectObject(dc, GetStockObject(NULL_BRUSH));
    DeleteObject(br);
}
 
 
void gfillpolygon(drawing d, rgb fill, point *p, int n)
{
   HDC dc = GETHDC(d);
   HBRUSH br = CreateSolidBrush(getwinrgb(d,fill));
   fix_brush(dc, d, br);
   SelectObject(dc, br);
   Polygon(dc, (POINT FAR *) p, n);
   SelectObject(dc, GetStockObject(NULL_BRUSH));
   DeleteObject(br);
}
 
/* For ordinary text, e.g. in console */
int gdrawstr(drawing d, font f, rgb c, point p, char *s)
{
    POINT curr_pos;
    int width;
    HFONT old;
    HDC dc = GETHDC(d);
 
    SetTextColor(dc, getwinrgb(d,c));
    old = SelectObject(dc, f->handle);
    MoveToEx(dc, p.x, p.y, NULL);
    SetBkMode(dc, TRANSPARENT);
    SetTextAlign(dc, TA_TOP | TA_LEFT | TA_UPDATECP);
 
    TextOut(dc, p.x, p.y, s, strlen(s));
 
    GetCurrentPositionEx(dc, &curr_pos);
    width = curr_pos.x - p.x;
    SelectObject(dc, old);
 
    return width;
}
 
/* This version aligns on baseline, and allows hadj = 0, 0.5, 1 */
void gdrawstr1(drawing d, font f, rgb c, point p, char *s, double hadj)
{
    HFONT old;
    HDC dc = GETHDC(d);
    UINT flags = TA_BASELINE | TA_UPDATECP;
 
    SetTextColor(dc, getwinrgb(d,c));
    old = SelectObject(dc, f->handle);
    MoveToEx(dc, p.x, p.y, NULL);
    SetBkMode(dc, TRANSPARENT);
    if (hadj < 0.25) flags |= TA_LEFT;
    else if (hadj < 0.75) flags |= TA_CENTER;
    else flags |= TA_RIGHT;
    SetTextAlign(dc, flags);
    TextOut(dc, p.x, p.y, s, strlen(s));
    SelectObject(dc, old);
}
 
rect gstrrect(drawing d, font f, char *s)
{
    SIZE size;
    HFONT old;
    HDC dc;
    if (! f)
	f = SystemFont;
    if (d)
	dc = GETHDC(d);
    else
	dc = GetDC(0);
    old = SelectObject(dc, f->handle);
    GetTextExtentPoint32(dc, (LPSTR)s, strlen(s), &size);
    SelectObject(dc, old);
    if (!d) ReleaseDC(0,dc);
    return rect(0, 0, size.cx, size.cy);
}
 
point gstrsize(drawing d, font f, char *s)
{
    rect r = gstrrect(d, f, s);
    return pt(r.width, r.height);
}
 
int gstrwidth(drawing d, font f, char *s)
{
    rect r = gstrrect(d,f,s);
    return r.width;
}
 
int ghasfixedwidth(font f)
{
    TEXTMETRIC tm;
    HFONT old;
    HDC dc = GetDC(0);
    old = SelectObject(dc, (HFONT)f->handle);
    GetTextMetrics(dc, &tm);
    SelectObject(dc, old);
    ReleaseDC(0,dc);
    return !(tm.tmPitchAndFamily & TMPF_FIXED_PITCH);
}
 
void gcharmetric(drawing d, font f, int c, int *ascent, int *descent,
		 int *width)
{
    int first, last, extra;
    TEXTMETRIC tm;
    HFONT old;
    HDC dc = GETHDC(d);
    old = SelectObject(dc, (HFONT)f->handle);
    GetTextMetrics(dc, &tm);
    first = tm.tmFirstChar;
    last = tm.tmLastChar;
    extra = tm.tmExternalLeading + tm.tmInternalLeading - 1;
    if(c < 0) { /* used for setting cra */
      SIZE size;
      char* cc="M";
      GetTextExtentPoint32(dc,(LPSTR) cc, 1, &size);
      *descent = tm.tmDescent ;
      *ascent = size.cy - *descent;
      *width = size.cx;
      if(*width > size.cy) *width = size.cy;
    } else if(c == 0) {
	*descent = tm.tmDescent ;
        *ascent = tm.tmHeight - *descent - extra ;
	*width = tm.tmMaxCharWidth ;
    } else if((first <= c) && (c <= last)) {
      SIZE size;
      GetTextExtentPoint32(dc,(LPSTR) &c, 1, &size);
      *descent = tm.tmDescent ;
      *ascent = size.cy - *descent - extra ;
      *width = size.cx;
      /*
	 Under NT, ' ' gives 0 ascent and descent, which seems
	 correct but this : (i) makes R engine to center in random way;
	 (ii) doesn't correspond to what 98 and X do (' ' is there
	 high as the full font)
      */
      if ((c!=' ') && (tm.tmPitchAndFamily & TMPF_TRUETYPE)) {
        GLYPHMETRICS gm;
        MAT2 m2;
	m2.eM11.value = m2.eM22.value = (WORD) 1 ;
	m2.eM21.value = m2.eM12.value = (WORD) 0 ;
	m2.eM11.fract = m2.eM12.fract =
	  m2.eM21.fract = m2.eM22.fract =  (short) 0 ;
        if (GetGlyphOutline(dc,c,GGO_METRICS,&gm,0,NULL,&m2) != GDI_ERROR) {
	  *descent = gm.gmBlackBoxY - gm.gmptGlyphOrigin.y ;
	  *ascent  = gm.gmptGlyphOrigin.y + 1;
        }
      }
    } else {
	*ascent = 0;
	*descent = 0;
	*width = 0;
    }
    SelectObject(dc, old);
}
 
font gnewfont(drawing d, char *face, int style, int size, double rot)
{
    font obj;
    HFONT hf;
    LOGFONT lf;
 
    if ((rot <= 45.0) || ((rot > 135) && (rot <= 225)) || (rot > 315))
	lf.lfHeight = -MulDiv(size, devicepixelsy(d), 72);
    else
	lf.lfHeight = -MulDiv(size, devicepixelsx(d), 72);
 
    lf.lfWidth = 0 ;
    lf.lfEscapement = lf.lfOrientation = (int) 10*rot;
    lf.lfWeight = FW_NORMAL;
    lf.lfItalic = lf.lfUnderline = lf.lfStrikeOut = 0;
    if ((! strcmp(face, "Symbol")) || (! strcmp(face, "Wingdings")))
	lf.lfCharSet = SYMBOL_CHARSET;
    else
	lf.lfCharSet = ANSI_CHARSET;
    lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
    lf.lfQuality = DEFAULT_QUALITY;
    lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
    if ((strlen(face) > 1) && (face[0] == 'T') && (face[1] == 'T')) {
        char *pf;
        lf.lfOutPrecision = OUT_TT_ONLY_PRECIS;
        for (pf = &face[2]; isspace(*pf) ; pf++);
        strncpy(lf.lfFaceName, pf, LF_FACESIZE-1);
    }
    else {
        lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
        strncpy(lf.lfFaceName, face, LF_FACESIZE-1);
    }
    if (style & Italic)
	lf.lfItalic = 1;
    if (style & Bold)
	lf.lfWeight = FW_BOLD;
    if (style & FixedWidth)
	lf.lfPitchAndFamily |= FIXED_PITCH;
    if (style & SansSerif)
	lf.lfPitchAndFamily |= FF_SWISS;
 
    if ((hf = CreateFontIndirect(&lf)) == 0)
	return NULL;
 
    obj = new_font_object(hf);
    if (obj)
	obj->text = new_string(face);
    if (d && ((d->kind == PrinterObject) ||
	      (d->kind == MetafileObject))) {
	TEXTMETRIC tm;
	HFONT old = SelectObject((HDC)d->handle, hf);
	GetTextMetrics((HDC)d->handle, &tm);
	obj->rect.width = tm.tmAveCharWidth;
	obj->rect.height = tm.tmHeight;
	obj->rect.x = tm.tmAscent - tm.tmInternalLeading;
	obj->rect.y = tm.tmDescent;
	SelectObject((HDC)d->handle, old);
    }
 
    return (font) obj;
}
 
 
static int measuredev(drawing dev, int what)
{
    HDC hDC;
    int n;
    if (dev)
	hDC = GETHDC(dev);
    else
	hDC = GetDC(NULL);
    n = GetDeviceCaps(hDC, what);
    if (!dev) ReleaseDC(NULL, hDC);
    return n;
}
 
#define MEASUREDEV(a) {return measuredev(dev,a);}
 
int devicewidth(drawing dev) MEASUREDEV(HORZRES)
int deviceheight(drawing dev) MEASUREDEV(VERTRES)
int devicewidthmm(drawing dev) MEASUREDEV(HORZSIZE)
int deviceheightmm(drawing dev) MEASUREDEV(VERTSIZE)
int devicepixelsx(drawing dev) MEASUREDEV(LOGPIXELSX)
int devicepixelsy(drawing dev) MEASUREDEV(LOGPIXELSY)
 
int isTopmost(window c)
{
    return GetWindowLong(c->handle, GWL_EXSTYLE) & WS_EX_TOPMOST;
}
 
void BringToTop(window c, int stay) /* stay=0 for regular, 1 for topmost, 2 for toggle */
{
    SetForegroundWindow(c->handle); /* needed in Rterm */
    BringWindowToTop(c->handle);    /* needed in Rgui --mdi */
 
    if (stay == 2) stay = !isTopmost(c);
 
    if (stay) SetWindowPos(c->handle, HWND_TOPMOST, 0, 0, 0, 0,
    				SWP_NOMOVE | SWP_NOSIZE);
    else SetWindowPos(c->handle, HWND_NOTOPMOST, 0, 0, 0, 0,
    				SWP_NOMOVE | SWP_NOSIZE);
}

Rev 27357	Rev 27686
1	`/*`	1	`/*`
2	`* R : A Computer Language for Statistical Data Analysis`	2	`* R : A Computer Language for Statistical Data Analysis`
3	`* Copyright (C) 1998--2001 Guido Masarotto and Brian Ripley`	3	`* Copyright (C) 1998--2001 Guido Masarotto and Brian Ripley`
4	`*`	4	`*`
5	`* This program is free software; you can redistribute it and/or modify`	5	`* This program is free software; you can redistribute it and/or modify`
6	`* it under the terms of the GNU General Public License as published by`	6	`* it under the terms of the GNU General Public License as published by`
7	`* the Free Software Foundation; either version 2 of the License, or`	7	`* the Free Software Foundation; either version 2 of the License, or`
8	`* (at your option) any later version.`	8	`* (at your option) any later version.`
9	`*`	9	`*`
10	`* This program is distributed in the hope that it will be useful,`	10	`* This program is distributed in the hope that it will be useful,`
11	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`	11	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
12	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`	12	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
13	`* GNU General Public License for more details.`	13	`* GNU General Public License for more details.`
14	`*`	14	`*`
15	`* You should have received a copy of the GNU General Public License`	15	`* You should have received a copy of the GNU General Public License`
16	`* along with this program; if not, write to the Free Software`	16	`* along with this program; if not, write to the Free Software`
17	`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`	17	`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`
18	`*/`	18	`*/`
19		19
20	`/*`	20	`/*`
21	`A version of drawing.c without current/state.`	21	`A version of drawing.c without current/state.`
22	`More safe in case of multiple redrawing`	22	`More safe in case of multiple redrawing`
23	`*/`	23	`*/`
24		24
25	`#include "internal.h"`	25	`#include "internal.h"`
26	`#include <winbase.h>`	26	`#include <winbase.h>`
27		27
28	`static HDC GETHDC(drawing d)`	28	`static HDC GETHDC(drawing d)`
29	`{`	29	`{`
30	`if (!d)`	30	`if (!d)`
31	`{`	31	`{`
32	`DebugBreak();`	32	`DebugBreak();`
33	`return (HDC) 0; /* We should never get here, but we do? */`	33	`return (HDC) 0; /* We should never get here, but we do? */`
34	`}`	34	`}`
35	`if ( (d->kind == PrinterObject)\|\| (d->kind == MetafileObject))`	35	`if ( (d->kind == PrinterObject)\|\| (d->kind == MetafileObject))`
36	`{`	36	`{`
37	`HDC dc = (HDC) d->handle ;`	37	`HDC dc = (HDC) d->handle ;`
38	`SelectObject(dc, GetStockObject(NULL_PEN));`	38	`SelectObject(dc, GetStockObject(NULL_PEN));`
39	`SelectObject(dc, GetStockObject(NULL_BRUSH));`	39	`SelectObject(dc, GetStockObject(NULL_BRUSH));`
40	`return dc ;`	40	`return dc ;`
41	`}`	41	`}`
42	`else`	42	`else`
43	`return get_context(d);`	43	`return get_context(d);`
44	`}`	44	`}`
45		45
46		46
47	`/*`	47	`/*`
48	`* Some clipping functions.`	48	`* Some clipping functions.`
49	`*/`	49	`*/`
50	`rect ggetcliprect(drawing d)`	50	`rect ggetcliprect(drawing d)`
51	`{`	51	`{`
52	`RECT R;`	52	`RECT R;`
53	`rect r;`	53	`rect r;`
54	`HDC dc = GETHDC(d);`	54	`HDC dc = GETHDC(d);`
55	`GetClipBox(dc, &R);`	55	`GetClipBox(dc, &R);`
56	`r.x = R.left;`	56	`r.x = R.left;`
57	`r.y = R.top;`	57	`r.y = R.top;`
58	`r.width = R.right - R.left;`	58	`r.width = R.right - R.left;`
59	`r.height = R.bottom - R.top;`	59	`r.height = R.bottom - R.top;`
60	`return r;`	60	`return r;`
61	`}`	61	`}`
62		62
63	`void gsetcliprect(drawing d, rect r)`	63	`void gsetcliprect(drawing d, rect r)`
64	`{`	64	`{`
65	`HRGN rgn;`	65	`HRGN rgn;`
66	`HDC dc = GETHDC(d);`	66	`HDC dc = GETHDC(d);`
67	`rgn = CreateRectRgn(r.x, r.y, r.x + r.width, r.y + r.height);`	67	`rgn = CreateRectRgn(r.x, r.y, r.x + r.width, r.y + r.height);`
68	`SelectClipRgn(dc, rgn);`	68	`SelectClipRgn(dc, rgn);`
69	`DeleteObject(rgn);`	69	`DeleteObject(rgn);`
70	`}`	70	`}`
71		71
72		72
73	`void gbitblt(drawing db, drawing sb, point p, rect r)`	73	`void gbitblt(drawing db, drawing sb, point p, rect r)`
74	`{`	74	`{`
75	`HDC src;`	75	`HDC src;`
76	`HDC dst;`	76	`HDC dst;`
77		77
78	`dst = GETHDC(db);`	78	`dst = GETHDC(db);`
79	`src = GETHDC(sb);`	79	`src = GETHDC(sb);`
80	`BitBlt(dst, p.x, p.y, r.width, r.height, src, r.x, r.y, SRCCOPY);`	80	`BitBlt(dst, p.x, p.y, r.width, r.height, src, r.x, r.y, SRCCOPY);`
81	`}`	81	`}`
82		82
83		83
84		84
85	`/* dp gives the amount to scroll; r the full rectangle to scroll */`	85	`/* dp gives the amount to scroll; r the full rectangle to scroll */`
86	`void gscroll(drawing d, point dp, rect r)`	86	`void gscroll(drawing d, point dp, rect r)`
87	`{`	87	`{`
88	`HDC dc = GETHDC(d);`	88	`HDC dc = GETHDC(d);`
89	`RECT rr ;`	89	`RECT rr ;`
90	`rr.left = r.x;`	90	`rr.left = r.x;`
91	`rr.top = r.y;`	91	`rr.top = r.y;`
92	`rr.right = r.x + r.width;`	92	`rr.right = r.x + r.width;`
93	`rr.bottom = r.y + r.height;`	93	`rr.bottom = r.y + r.height;`
94	`ScrollDC(dc, dp.x , dp.y , &rr, &rr, 0, NULL);`	94	`ScrollDC(dc, dp.x , dp.y , &rr, &rr, 0, NULL);`
95	`}`	95	`}`
96		96
97	`void ginvert(drawing d, rect r)`	97	`void ginvert(drawing d, rect r)`
98	`{`	98	`{`
99	`HDC dc = GETHDC(d);`	99	`HDC dc = GETHDC(d);`
100		100
101	`PatBlt(dc, r.x, r.y, r.width, r.height, DSTINVERT);`	101	`PatBlt(dc, r.x, r.y, r.width, r.height, DSTINVERT);`
102	`}`	102	`}`
103		103
104	`rgb ggetpixel(drawing d, point p)`	104	`rgb ggetpixel(drawing d, point p)`
105	`{`	105	`{`
106	`rgb c;`	106	`rgb c;`
107	`HDC dc = GETHDC(d);`	107	`HDC dc = GETHDC(d);`
108		108
109	`c = GetPixel(dc, p.x, p.y);`	109	`c = GetPixel(dc, p.x, p.y);`
110	`c = ((c&0x000000FFL)<<16) \| (c&0x0000FF00L) \|`	110	`c = ((c&0x000000FFL)<<16) \| (c&0x0000FF00L) \|`
111	`((c&0x00FF0000L)>>16);`	111	`((c&0x00FF0000L)>>16);`
112	`return c;`	112	`return c;`
113	`}`	113	`}`
114		114
115	`static COLORREF getwinrgb(drawing d, rgb c)`	115	`static COLORREF getwinrgb(drawing d, rgb c)`
116	`{`	116	`{`
117	`int r, g, b;`	117	`int r, g, b;`
118	`long luminance;`	118	`long luminance;`
119	`int depth;`	119	`int depth;`
120		120
121	`r = (int) ((c >> 16) & 0x000000FFL);`	121	`r = (int) ((c >> 16) & 0x000000FFL);`
122	`g = (int) ((c >> 8) & 0x000000FFL);`	122	`g = (int) ((c >> 8) & 0x000000FFL);`
123	`b = (int) ((c >> 0) & 0x000000FFL);`	123	`b = (int) ((c >> 0) & 0x000000FFL);`
124	`depth = getdepth(d);`	124	`depth = getdepth(d);`
125	`if (depth <= 2) /* map to black or white, or grey if c == Grey */`	125	`if (depth <= 2) /* map to black or white, or grey if c == Grey */`
126	`{`	126	`{`
127	`luminance = (r3 + g5 + b) / 9;`	127	`luminance = (r3 + g5 + b) / 9;`
128	`if (luminance > 0x0087) r = g = b = 0x00FF;`	128	`if (luminance > 0x0087) r = g = b = 0x00FF;`
129	`else if (luminance <= 0x0077) r = g = b = 0x0000;`	129	`else if (luminance <= 0x0077) r = g = b = 0x0000;`
130	`else r = g = b = 0x0080;`	130	`else r = g = b = 0x0080;`
131	`c = rgb(r, g, b);`	131	`c = rgb(r, g, b);`
132	`}`	132	`}`
133	`return RGB(r, g, b);`	133	`return RGB(r, g, b);`
134	`}`	134	`}`
135		135
136	`void gsetpixel(drawing d, point p, rgb c)`	136	`void gsetpixel(drawing d, point p, rgb c)`
137	`{`	137	`{`
138	`HDC dc = GETHDC(d);`	138	`HDC dc = GETHDC(d);`
139	`HBRUSH br = CreateSolidBrush(getwinrgb(d, c));`	139	`HBRUSH br = CreateSolidBrush(getwinrgb(d, c));`
140		140
141	`fix_brush(dc, d, br);`	141	`fix_brush(dc, d, br);`
142	`SelectObject(dc, br);`	142	`SelectObject(dc, br);`
143	`PatBlt(dc, p.x, p.y, 1, 1, PATCOPY);`	143	`PatBlt(dc, p.x, p.y, 1, 1, PATCOPY);`
144	`SelectObject(dc, GetStockObject(NULL_BRUSH));`	144	`SelectObject(dc, GetStockObject(NULL_BRUSH));`
145	`DeleteObject(br);`	145	`DeleteObject(br);`
146	`}`	146	`}`
147		147
148	`typedef struct {`	148	`typedef struct {`
149	`HDC dc;`	149	`HDC dc;`
150	`int len2; /* squared length of current dash */`	150	`int len2; /* squared length of current dash */`
151	`int curseg, on; /* current dash (0-7), on/off flag */`	151	`int curseg, on; /* current dash (0-7), on/off flag */`
152	`int style, width;`	152	`int style, width;`
153	`int curx, cury; /* start of current dash */`	153	`int curx, cury; /* start of current dash */`
154	`} DashStruct;`	154	`} DashStruct;`
155		155
156	`static int npieces;`	156	`static int npieces;`
157		157
158	`static void CALLBACK gLineHelper(int x, int y, LPARAM aa)`	158	`static void CALLBACK gLineHelper(int x, int y, LPARAM aa)`
159	`{`	159	`{`
160	`DashStruct a = (DashStruct ) aa;`	160	`DashStruct a = (DashStruct ) aa;`
161	`int distx, disty;`	161	`int distx, disty;`
162		162
163	`npieces++;`	163	`npieces++;`
164	`distx = x - (a->curx);`	164	`distx = x - (a->curx);`
165	`disty = y - (a->cury);`	165	`disty = y - (a->cury);`
166	`if (distxdistx + distydisty >= (a->len2)) {`	166	`if (distxdistx + distydisty >= (a->len2)) {`
167	`if (a->on)`	167	`if (a->on)`
168	`LineTo(a->dc, x, y);`	168	`LineTo(a->dc, x, y);`
169	`else`	169	`else`
170	`MoveToEx(a->dc, x, y, NULL);`	170	`MoveToEx(a->dc, x, y, NULL);`
171	`a->curx = x;`	171	`a->curx = x;`
172	`a->cury = y;`	172	`a->cury = y;`
173	`a->len2 = 0;`	173	`a->len2 = 0;`
174	`while (!a->len2) {`	174	`while (!a->len2) {`
175	`a->curseg = (a->curseg + 4) % 32;`	175	`a->curseg = (a->curseg + 4) % 32;`
176	`a->len2 = (((a->style) >> (a->curseg)) & 15) * (a->width);`	176	`a->len2 = (((a->style) >> (a->curseg)) & 15) * (a->width);`
177	`a->len2 = (a->len2) * (a->len2);`	177	`a->len2 = (a->len2) * (a->len2);`
178	`a->on = (a->on) ? 0 : 1;`	178	`a->on = (a->on) ? 0 : 1;`
179	`}`	179	`}`
180	`}`	180	`}`
181	`}`	181	`}`
182		182
183	`void gdrawline(drawing d, int width, int style, rgb c, point p1, point p2,`	183	`void gdrawline(drawing d, int width, int style, rgb c, point p1, point p2,`
184	`int fast)`	184	`int fast)`
185	`{`	185	`{`
186	`point p[2];`	186	`point p[2];`
187	`p[0] = p1;`	187	`p[0] = p1;`
188	`p[1] = p2;`	188	`p[1] = p2;`
189	`gdrawpolyline( d, width, style, c, p, 2, 0, fast);`	189	`gdrawpolyline( d, width, style, c, p, 2, 0, fast);`
190	`}`	190	`}`
191		191
192	`void gdrawpolyline(drawing d, int width, int style, rgb c,`	192	`void gdrawpolyline(drawing d, int width, int style, rgb c,`
193	`point p[], int n, int closepath, int fast)`	193	`point p[], int n, int closepath, int fast)`
194	`{`	194	`{`
195	`int tmpx, tmpy, tmp;`	195	`int tmpx, tmpy, tmp;`
196	`HDC dc = GETHDC(d);`	196	`HDC dc = GETHDC(d);`
197	`COLORREF winrgb = getwinrgb(d, c);`	197	`COLORREF winrgb = getwinrgb(d, c);`
198	`LOGBRUSH lb;`	198	`LOGBRUSH lb;`
199	`HPEN gpen;`	199	`HPEN gpen;`
200	`int i;`	200	`int i;`
201		201
202	`if (n < 2) return;`	202	`if (n < 2) return;`
203	`lb.lbStyle = BS_SOLID;`	203	`lb.lbStyle = BS_SOLID;`
204	`lb.lbColor = winrgb;`	204	`lb.lbColor = winrgb;`
205	`lb.lbHatch = 0;`	205	`lb.lbHatch = 0;`
206	`if (!style) {`	206	`if (!style) {`
207	`if (fast)`	207	`if (fast)`
208	`gpen = CreatePen(PS_INSIDEFRAME, width, winrgb);`	208	`gpen = CreatePen(PS_INSIDEFRAME, width, winrgb);`
209	`else`	209	`else`
210	`gpen = ExtCreatePen(PS_GEOMETRIC\|PS_SOLID\|PS_ENDCAP_FLAT\|PS_JOIN_ROUND,`	210	`gpen = ExtCreatePen(PS_GEOMETRIC\|PS_SOLID\|PS_ENDCAP_FLAT\|PS_JOIN_ROUND,`
211	`width, &lb, 0, NULL);`	211	`width, &lb, 0, NULL);`
212	`SelectObject(dc, gpen);`	212	`SelectObject(dc, gpen);`
213	`SetROP2(dc, R2_COPYPEN);`	213	`SetROP2(dc, R2_COPYPEN);`
214	`MoveToEx(dc, p[0].x, p[0].y, NULL);`	214	`MoveToEx(dc, p[0].x, p[0].y, NULL);`
215	`for (i = 1; i < n ; i++)`	215	`for (i = 1; i < n ; i++)`
216	`LineTo(dc, p[i].x, p[i].y);`	216	`LineTo(dc, p[i].x, p[i].y);`
217	`if (closepath) LineTo(dc, p[0].x, p[0].y);`	217	`if (closepath) LineTo(dc, p[0].x, p[0].y);`
218	`SelectObject(dc, GetStockObject(NULL_PEN));`	218	`SelectObject(dc, GetStockObject(NULL_PEN));`
219	`DeleteObject(gpen);`	219	`DeleteObject(gpen);`
220	`}`	220	`}`
221	`else {`	221	`else {`
222	`DashStruct a;`	222	`DashStruct a;`
223	`gpen = ExtCreatePen(PS_GEOMETRIC\|PS_SOLID\|PS_ENDCAP_FLAT\|PS_JOIN_ROUND,`	223	`gpen = ExtCreatePen(PS_GEOMETRIC\|PS_SOLID\|PS_ENDCAP_FLAT\|PS_JOIN_ROUND,`
224	`width, &lb, 0, NULL);`	224	`width, &lb, 0, NULL);`
225	`SelectObject(dc, gpen);`	225	`SelectObject(dc, gpen);`
226	`SetROP2(dc, R2_COPYPEN);`	226	`SetROP2(dc, R2_COPYPEN);`
227	`a.on = 1;`	227	`a.on = 1;`
228	`a.dc = dc;`	228	`a.dc = dc;`
229	`a.len2 = (style & 15) * width;`	229	`a.len2 = (style & 15) * width;`
230	`a.len2 = (a.len2) * (a.len2);`	230	`a.len2 = (a.len2) * (a.len2);`
231	`a.curseg = 0;`	231	`a.curseg = 0;`
232	`a.style = style;`	232	`a.style = style;`
233	`a.width = width;`	233	`a.width = width;`
234	`a.curx = p[0].x;`	234	`a.curx = p[0].x;`
235	`a.cury = p[0].y;`	235	`a.cury = p[0].y;`
236	`MoveToEx(dc, p[0].x, p[0].y, NULL);`	236	`MoveToEx(dc, p[0].x, p[0].y, NULL);`
237	`npieces = 0;`	237	`npieces = 0;`
238	`BeginPath(dc);`	238	`BeginPath(dc);`
239	`for (i = 1; i < n; i++) {`	239	`for (i = 1; i < n; i++) {`
240	`LineDDA(p[i-1].x, p[i-1].y, p[i].x, p[i].y, gLineHelper,`	240	`LineDDA(p[i-1].x, p[i-1].y, p[i].x, p[i].y, gLineHelper,`
241	`(LPARAM) &a);`	241	`(LPARAM) &a);`
242	`if ((p[i].x != a.curx) \|\| (p[i].y != a.cury)) {`	242	`if ((p[i].x != a.curx) \|\| (p[i].y != a.cury)) {`
243	`if (a.on) LineTo(dc, p[i].x, p[i].y);`	243	`if (a.on) LineTo(dc, p[i].x, p[i].y);`
244	`else MoveToEx(dc, p[i].x, p[i].y, NULL);`	244	`else MoveToEx(dc, p[i].x, p[i].y, NULL);`
245	`tmpx = (a.curx-p[i].x);`	245	`tmpx = (a.curx-p[i].x);`
246	`tmpy = (a.cury-p[i].y);`	246	`tmpy = (a.cury-p[i].y);`
247	`tmp = tmpxtmpx + tmpytmpy;`	247	`tmp = tmpxtmpx + tmpytmpy;`
248	`a.len2 = a.len2 + tmp - 2sqrt((double)(tmpa.len2));`	248	`a.len2 = a.len2 + tmp - 2sqrt((double)(tmpa.len2));`
249	`a.curx = p[i].x;`	249	`a.curx = p[i].x;`
250	`a.cury = p[i].y;`	250	`a.cury = p[i].y;`
251	`}`	251	`}`
252	`if(npieces > 5000) {`	252	`if(npieces > 5000) {`
253	`EndPath(dc);`	253	`EndPath(dc);`
254	`StrokePath(dc);`	254	`StrokePath(dc);`
255	`npieces = 0;`	255	`npieces = 0;`
256	`BeginPath(dc);`	256	`BeginPath(dc);`
257	`}`	257	`}`
258	`}`	258	`}`
259	`if (closepath) {`	259	`if (closepath) {`
260	`LineDDA(p[n-1].x, p[n-1].y, p[0].x, p[0].y, gLineHelper,`	260	`LineDDA(p[n-1].x, p[n-1].y, p[0].x, p[0].y, gLineHelper,`
261	`(LPARAM) &a);`	261	`(LPARAM) &a);`
262	`if (a.on) LineTo(dc,p[0].x,p[0].y);`	262	`if (a.on) LineTo(dc,p[0].x,p[0].y);`
263	`}`	263	`}`
264	`EndPath(dc);`	264	`EndPath(dc);`
265	`StrokePath(dc);`	265	`StrokePath(dc);`
266	`SelectObject(dc, GetStockObject(NULL_PEN));`	266	`SelectObject(dc, GetStockObject(NULL_PEN));`
267	`DeleteObject(gpen);`	267	`DeleteObject(gpen);`
268	`}`	268	`}`
269	`}`	269	`}`
270		270
271	`void gdrawrect(drawing d, int width, int style, rgb c, rect r, int fast)`	271	`void gdrawrect(drawing d, int width, int style, rgb c, rect r, int fast)`
272	`{`	272	`{`
273	`int x0 = r.x;`	273	`int x0 = r.x;`
274	`int y0 = r.y;`	274	`int y0 = r.y;`
275	`int x1 = r.x + r.width;`	275	`int x1 = r.x + r.width;`
276	`int y1 = r.y + r.height;`	276	`int y1 = r.y + r.height;`
277	`point p[4];`	277	`point p[4];`
278	`p[0] = pt(x0,y0);`	278	`p[0] = pt(x0,y0);`
279	`p[1] = pt(x1,y0);`	279	`p[1] = pt(x1,y0);`
280	`p[2] = pt(x1,y1);`	280	`p[2] = pt(x1,y1);`
281	`p[3] = pt(x0,y1);`	281	`p[3] = pt(x0,y1);`
282	`gdrawpolyline(d, width, style, c, p, 4, 1, fast);`	282	`gdrawpolyline(d, width, style, c, p, 4, 1, fast);`
283	`}`	283	`}`
284		284
285	`void gfillrect(drawing d, rgb fill, rect r)`	285	`void gfillrect(drawing d, rgb fill, rect r)`
286	`{`	286	`{`
287	`HDC dc = GETHDC(d);`	287	`HDC dc = GETHDC(d);`
288	`HBRUSH br = CreateSolidBrush(getwinrgb(d, fill));`	288	`HBRUSH br = CreateSolidBrush(getwinrgb(d, fill));`
289	`fix_brush(dc, d, br);`	289	`fix_brush(dc, d, br);`
290	`SelectObject(dc, br);`	290	`SelectObject(dc, br);`
291	`PatBlt(dc, r.x, r.y, r.width, r.height, PATCOPY);`	291	`PatBlt(dc, r.x, r.y, r.width, r.height, PATCOPY);`
292	`SelectObject(dc, GetStockObject(NULL_BRUSH));`	292	`SelectObject(dc, GetStockObject(NULL_BRUSH));`
293	`DeleteObject(br);`	293	`DeleteObject(br);`
294	`}`	294	`}`
295		295
296	`void gdrawellipse(drawing d, int width, rgb border, rect r, int fast)`	296	`void gdrawellipse(drawing d, int width, rgb border, rect r, int fast)`
297	`{`	297	`{`
298	`HDC dc = GETHDC(d);`	298	`HDC dc = GETHDC(d);`
299	`LOGBRUSH lb;`	299	`LOGBRUSH lb;`
300	`HPEN gpen;`	300	`HPEN gpen;`
301	`if (fast)`	301	`if (fast)`
302	`gpen = CreatePen(PS_INSIDEFRAME, width, getwinrgb(d, border));`	302	`gpen = CreatePen(PS_INSIDEFRAME, width, getwinrgb(d, border));`
303	`else {`	303	`else {`
304	`lb.lbStyle = BS_SOLID;`	304	`lb.lbStyle = BS_SOLID;`
305	`lb.lbColor = getwinrgb(d, border);`	305	`lb.lbColor = getwinrgb(d, border);`
306	`lb.lbHatch = 0;`	306	`lb.lbHatch = 0;`
307	`gpen = ExtCreatePen(PS_GEOMETRIC\|PS_SOLID\|PS_ENDCAP_FLAT\|PS_JOIN_ROUND,`	307	`gpen = ExtCreatePen(PS_GEOMETRIC\|PS_SOLID\|PS_ENDCAP_FLAT\|PS_JOIN_ROUND,`
308	`width, &lb, 0, NULL);`	308	`width, &lb, 0, NULL);`
309	`}`	309	`}`
310	`SelectObject(dc, gpen);`	310	`SelectObject(dc, gpen);`
311	`SetROP2(dc, R2_COPYPEN);`	311	`SetROP2(dc, R2_COPYPEN);`
312	`Ellipse(dc, r.x, r.y, r.x+r.width, r.y+r.height);`	312	`Ellipse(dc, r.x, r.y, r.x+r.width, r.y+r.height);`
313	`SelectObject(dc, GetStockObject(NULL_PEN));`	313	`SelectObject(dc, GetStockObject(NULL_PEN));`
314	`DeleteObject(gpen);`	314	`DeleteObject(gpen);`
315	`}`	315	`}`
316		316
317	`void goldfillellipse(drawing d, rgb fill, rect r)`	317	`void goldfillellipse(drawing d, rgb fill, rect r)`
318	`{`	318	`{`
319	`HDC dc = GETHDC(d);`	319	`HDC dc = GETHDC(d);`
320	`HBRUSH br = CreateSolidBrush(getwinrgb(d, fill));`	320	`HBRUSH br = CreateSolidBrush(getwinrgb(d, fill));`
321	`fix_brush(dc, d, br);`	321	`fix_brush(dc, d, br);`
322	`SelectObject(dc, br);`	322	`SelectObject(dc, br);`
323	`Ellipse(dc, r.x, r.y, r.x+r.width, r.y+r.height);`	323	`Ellipse(dc, r.x, r.y, r.x+r.width, r.y+r.height);`
324	`SelectObject(dc, GetStockObject(NULL_BRUSH));`	324	`SelectObject(dc, GetStockObject(NULL_BRUSH));`
325	`DeleteObject(br);`	325	`DeleteObject(br);`
326	`}`	326	`}`
327		327
328		328
329	`#ifndef fastfillrect`	329	`#ifndef fastfillrect`
330	`#define fastfillrect(x, y, w, h) PatBlt(dc, (x), (y), (w), (h), mode)`	330	`#define fastfillrect(x, y, w, h) PatBlt(dc, (x), (y), (w), (h), mode)`
331	`#endif`	331	`#endif`
332		332
333	`void gfillellipse(drawing d, rgb fill, rect r)`	333	`void gfillellipse(drawing d, rgb fill, rect r)`
334	`{ /* e(x,y) = bbxx + aayy - aabb /`	334	`{ /* e(x,y) = bbxx + aayy - aabb /`
335	`register long mode = PATCOPY;`	335	`register long mode = PATCOPY;`
336	`int w_odd = (r.width & 0x0001);`	336	`int w_odd = (r.width & 0x0001);`
337	`int h_odd = (r.height & 0x0001);`	337	`int h_odd = (r.height & 0x0001);`
338	`int a = r.width >> 1;`	338	`int a = r.width >> 1;`
339	`int b = r.height >> 1;`	339	`int b = r.height >> 1;`
340	`point c = pt(r.x+a,r.y+b);`	340	`point c = pt(r.x+a,r.y+b);`
341	`int x = 0;`	341	`int x = 0;`
342	`int y = b;`	342	`int y = b;`
343	`long a2 = a*a;`	343	`long a2 = a*a;`
344	`long b2 = b*b;`	344	`long b2 = b*b;`
345	`long xcrit = ((a2+a2+a2) >> 2) + 1;`	345	`long xcrit = ((a2+a2+a2) >> 2) + 1;`
346	`long ycrit = ((b2+b2+b2) >> 2) + 1;`	346	`long ycrit = ((b2+b2+b2) >> 2) + 1;`
347	`long t = b2 + a2 - (a2+a2)b; / t = e(x+1,y-1) */`	347	`long t = b2 + a2 - (a2+a2)b; / t = e(x+1,y-1) */`
348	`long dxt = b2*(3+x+x);`	348	`long dxt = b2*(3+x+x);`
349	`long dyt = a2*(3-y-y);`	349	`long dyt = a2*(3-y-y);`
350	`int d2xt = b2+b2;`	350	`int d2xt = b2+b2;`
351	`int d2yt = a2+a2;`	351	`int d2yt = a2+a2;`
352	`int stored = 0;`	352	`int stored = 0;`
353	`int sx = 0, sy = 0, sh = 0; /* stored values of x, y, height */`	353	`int sx = 0, sy = 0, sh = 0; /* stored values of x, y, height */`
354	`HDC dc;`	354	`HDC dc;`
355	`HBRUSH br;`	355	`HBRUSH br;`
356		356
357	`if ((r.width > 31) && (r.height > 31)) {`	357	`if ((r.width > 31) && (r.height > 31)) {`
358	`goldfillellipse(d, fill, r);`	358	`goldfillellipse(d, fill, r);`
359	`return;`	359	`return;`
360	`}`	360	`}`
361	`if ((r.width < 3) \|\| (r.height < 3)) {`	361	`if ((r.width < 3) \|\| (r.height < 3)) {`
362	`gfillrect(d, fill, r);`	362	`gfillrect(d, fill, r);`
363	`return;`	363	`return;`
364	`}`	364	`}`
365	`dc = GETHDC(d);`	365	`dc = GETHDC(d);`
366	`br = CreateSolidBrush(getwinrgb(d, fill));`	366	`br = CreateSolidBrush(getwinrgb(d, fill));`
367	`fix_brush(dc, d, br);`	367	`fix_brush(dc, d, br);`
368	`SelectObject(dc, br);`	368	`SelectObject(dc, br);`
369		369
370	`if (w_odd == 0) {`	370	`if (w_odd == 0) {`
371	`fastfillrect(c.x-1,c.y-b,2,r.height);`	371	`fastfillrect(c.x-1,c.y-b,2,r.height);`
372	`}`	372	`}`
373		373
374	`while (y > 0) {`	374	`while (y > 0) {`
375	`if (stored) {`	375	`if (stored) {`
376	`if (sx != x) { /* output stored rect */`	376	`if (sx != x) { /* output stored rect */`
377	`fastfillrect(c.x-sx,c.y-sy, sx+sx+w_odd,sh);`	377	`fastfillrect(c.x-sx,c.y-sy, sx+sx+w_odd,sh);`
378	`fastfillrect(c.x-sx,c.y+sy+h_odd-sh, sx+sx+w_odd,sh);`	378	`fastfillrect(c.x-sx,c.y+sy+h_odd-sh, sx+sx+w_odd,sh);`
379	`stored = 0;`	379	`stored = 0;`
380	`}`	380	`}`
381	`else /* increment height of stored rect */`	381	`else /* increment height of stored rect */`
382	`sh++;`	382	`sh++;`
383	`}`	383	`}`
384	`if (t + a2y < xcrit) { / e(x+1,y-1/2) <= 0 */`	384	`if (t + a2y < xcrit) { / e(x+1,y-1/2) <= 0 */`
385	`/* move left and right to encounter edge */`	385	`/* move left and right to encounter edge */`
386	`x += 1;`	386	`x += 1;`
387	`t += dxt;`	387	`t += dxt;`
388	`dxt += d2xt;`	388	`dxt += d2xt;`
389	`} else if (t - b2x >= ycrit) { / e(x+1/2,y-1) > 0 */`	389	`} else if (t - b2x >= ycrit) { / e(x+1/2,y-1) > 0 */`
390	`/* drop down one line */`	390	`/* drop down one line */`
391	`if (!stored) {`	391	`if (!stored) {`
392	`sx = x;`	392	`sx = x;`
393	`sy = y;`	393	`sy = y;`
394	`sh = 1;`	394	`sh = 1;`
395	`stored = 1;`	395	`stored = 1;`
396	`}`	396	`}`
397	`y -= 1;`	397	`y -= 1;`
398	`t += dyt;`	398	`t += dyt;`
399	`dyt += d2yt;`	399	`dyt += d2yt;`
400	`} else {`	400	`} else {`
401	`/* drop diagonally down and out */`	401	`/* drop diagonally down and out */`
402	`if (!stored) {`	402	`if (!stored) {`
403	`sx = x;`	403	`sx = x;`
404	`sy = y;`	404	`sy = y;`
405	`sh = 1;`	405	`sh = 1;`
406	`stored = 1;`	406	`stored = 1;`
407	`}`	407	`}`
408		408
409	`x += 1;`	409	`x += 1;`
410	`y -= 1;`	410	`y -= 1;`
411	`t += dxt + dyt;`	411	`t += dxt + dyt;`
412	`dxt += d2xt;`	412	`dxt += d2xt;`
413	`dyt += d2yt;`	413	`dyt += d2yt;`
414	`}`	414	`}`
415	`}`	415	`}`
416	`if (stored) { /* output stored rectangle */`	416	`if (stored) { /* output stored rectangle */`
417	`fastfillrect(c.x-sx, c.y-sy, sx+sx+w_odd, sh);`	417	`fastfillrect(c.x-sx, c.y-sy, sx+sx+w_odd, sh);`
418	`fastfillrect(c.x-sx, c.y+sy+h_odd-sh, sx+sx+w_odd, sh);`	418	`fastfillrect(c.x-sx, c.y+sy+h_odd-sh, sx+sx+w_odd, sh);`
419	`stored = 0;`	419	`stored = 0;`
420	`}`	420	`}`
421	`if (x <= a){`	421	`if (x <= a){`
422	`fastfillrect(c.x-a, c.y-y, a+a+w_odd, 1);`	422	`fastfillrect(c.x-a, c.y-y, a+a+w_odd, 1);`
423	`fastfillrect(c.x-a, c.y+y-1+h_odd, a+a+w_odd, 1);`	423	`fastfillrect(c.x-a, c.y+y-1+h_odd, a+a+w_odd, 1);`
424	`}`	424	`}`
425	`SelectObject(dc, GetStockObject(NULL_BRUSH));`	425	`SelectObject(dc, GetStockObject(NULL_BRUSH));`
426	`DeleteObject(br);`	426	`DeleteObject(br);`
427	`}`	427	`}`
428		428
429		429
430	`void gfillpolygon(drawing d, rgb fill, point *p, int n)`	430	`void gfillpolygon(drawing d, rgb fill, point *p, int n)`
431	`{`	431	`{`
432	`HDC dc = GETHDC(d);`	432	`HDC dc = GETHDC(d);`
433	`HBRUSH br = CreateSolidBrush(getwinrgb(d,fill));`	433	`HBRUSH br = CreateSolidBrush(getwinrgb(d,fill));`
434	`fix_brush(dc, d, br);`	434	`fix_brush(dc, d, br);`
435	`SelectObject(dc, br);`	435	`SelectObject(dc, br);`
436	`Polygon(dc, (POINT FAR *) p, n);`	436	`Polygon(dc, (POINT FAR *) p, n);`
437	`SelectObject(dc, GetStockObject(NULL_BRUSH));`	437	`SelectObject(dc, GetStockObject(NULL_BRUSH));`
438	`DeleteObject(br);`	438	`DeleteObject(br);`
439	`}`	439	`}`
440		440
441	`/* For ordinary text, e.g. in console */`	441	`/* For ordinary text, e.g. in console */`
442	`int gdrawstr(drawing d, font f, rgb c, point p, char *s)`	442	`int gdrawstr(drawing d, font f, rgb c, point p, char *s)`
443	`{`	443	`{`
444	`POINT curr_pos;`	444	`POINT curr_pos;`
445	`int width;`	445	`int width;`
446	`HFONT old;`	446	`HFONT old;`
447	`HDC dc = GETHDC(d);`	447	`HDC dc = GETHDC(d);`
448		448
449	`SetTextColor(dc, getwinrgb(d,c));`	449	`SetTextColor(dc, getwinrgb(d,c));`
450	`old = SelectObject(dc, f->handle);`	450	`old = SelectObject(dc, f->handle);`
451	`MoveToEx(dc, p.x, p.y, NULL);`	451	`MoveToEx(dc, p.x, p.y, NULL);`
452	`SetBkMode(dc, TRANSPARENT);`	452	`SetBkMode(dc, TRANSPARENT);`
453	`SetTextAlign(dc, TA_TOP \| TA_LEFT \| TA_UPDATECP);`	453	`SetTextAlign(dc, TA_TOP \| TA_LEFT \| TA_UPDATECP);`
454		454
455	`TextOut(dc, p.x, p.y, s, strlen(s));`	455	`TextOut(dc, p.x, p.y, s, strlen(s));`
456		456
457	`GetCurrentPositionEx(dc, &curr_pos);`	457	`GetCurrentPositionEx(dc, &curr_pos);`
458	`width = curr_pos.x - p.x;`	458	`width = curr_pos.x - p.x;`
459	`SelectObject(dc, old);`	459	`SelectObject(dc, old);`
460		460
461	`return width;`	461	`return width;`
462	`}`	462	`}`
463		463
464	`/* This version aligns on baseline, and allows hadj = 0, 0.5, 1 */`	464	`/* This version aligns on baseline, and allows hadj = 0, 0.5, 1 */`
465	`void gdrawstr1(drawing d, font f, rgb c, point p, char *s, double hadj)`	465	`void gdrawstr1(drawing d, font f, rgb c, point p, char *s, double hadj)`
466	`{`	466	`{`
467	`HFONT old;`	467	`HFONT old;`
468	`HDC dc = GETHDC(d);`	468	`HDC dc = GETHDC(d);`
469	`UINT flags = TA_BASELINE \| TA_UPDATECP;`	469	`UINT flags = TA_BASELINE \| TA_UPDATECP;`
470		470
471	`SetTextColor(dc, getwinrgb(d,c));`	471	`SetTextColor(dc, getwinrgb(d,c));`
472	`old = SelectObject(dc, f->handle);`	472	`old = SelectObject(dc, f->handle);`
473	`MoveToEx(dc, p.x, p.y, NULL);`	473	`MoveToEx(dc, p.x, p.y, NULL);`
474	`SetBkMode(dc, TRANSPARENT);`	474	`SetBkMode(dc, TRANSPARENT);`
475	`if (hadj < 0.25) flags \|= TA_LEFT;`	475	`if (hadj < 0.25) flags \|= TA_LEFT;`
476	`else if (hadj < 0.75) flags \|= TA_CENTER;`	476	`else if (hadj < 0.75) flags \|= TA_CENTER;`
477	`else flags \|= TA_RIGHT;`	477	`else flags \|= TA_RIGHT;`
478	`SetTextAlign(dc, flags);`	478	`SetTextAlign(dc, flags);`
479	`TextOut(dc, p.x, p.y, s, strlen(s));`	479	`TextOut(dc, p.x, p.y, s, strlen(s));`
480	`SelectObject(dc, old);`	480	`SelectObject(dc, old);`
481	`}`	481	`}`
482		482
483	`rect gstrrect(drawing d, font f, char *s)`	483	`rect gstrrect(drawing d, font f, char *s)`
484	`{`	484	`{`
485	`SIZE size;`	485	`SIZE size;`
486	`HFONT old;`	486	`HFONT old;`
487	`HDC dc;`	487	`HDC dc;`
488	`if (! f)`	488	`if (! f)`
489	`f = SystemFont;`	489	`f = SystemFont;`
490	`if (d)`	490	`if (d)`
491	`dc = GETHDC(d);`	491	`dc = GETHDC(d);`
492	`else`	492	`else`
493	`dc = GetDC(0);`	493	`dc = GetDC(0);`
494	`old = SelectObject(dc, f->handle);`	494	`old = SelectObject(dc, f->handle);`
495	`GetTextExtentPoint32(dc, (LPSTR)s, strlen(s), &size);`	495	`GetTextExtentPoint32(dc, (LPSTR)s, strlen(s), &size);`
496	`SelectObject(dc, old);`	496	`SelectObject(dc, old);`
497	`if (!d) ReleaseDC(0,dc);`	497	`if (!d) ReleaseDC(0,dc);`
498	`return rect(0, 0, size.cx, size.cy);`	498	`return rect(0, 0, size.cx, size.cy);`
499	`}`	499	`}`
500		500

The R Project SVN R

(root)/trunk/src/gnuwin32/graphapp/gdraw.c @ 28362 – Rev 27357 → 27686