summaryrefslogtreecommitdiff
path: root/src/sim/sim_primitives.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/sim/sim_primitives.c')
-rw-r--r--src/sim/sim_primitives.c1472
1 files changed, 1060 insertions, 412 deletions
diff --git a/src/sim/sim_primitives.c b/src/sim/sim_primitives.c
index a0a2e77..fc0c96c 100644
--- a/src/sim/sim_primitives.c
+++ b/src/sim/sim_primitives.c
@@ -11,35 +11,30 @@
#include "cd.h"
#include "cd_private.h"
-#include "cd_truetype.h"
-#include "sim.h"
-void cdlineSIM(cdCtxCanvas* ctxcanvas, int x1, int y1, int x2, int y2)
+
+void cdSimLine(cdCtxCanvas* ctxcanvas, int x1, int y1, int x2, int y2)
{
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
- int old_use_matrix = canvas->use_matrix;
-
- if (canvas->use_matrix && !canvas->invert_yaxis)
- {
- cdMatrixTransformPoint(canvas->matrix, x1, y1, &x1, &y1);
- cdMatrixTransformPoint(canvas->matrix, x2, y2, &x2, &y2);
- }
-
- /* must disable transformation here, because line simulation use cxPixel */
- canvas->use_matrix = 0;
-
- if(canvas->line_width > 1)
- simLineThick(canvas, x1, y1, x2, y2);
- else
- simLineThin(canvas, x1, y1, x2, y2);
+ cdPoint poly[2];
+ poly[0].x = x1; poly[0].y = y1;
+ poly[1].x = x2; poly[1].y = y2;
+ canvas->cxPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, 2);
+}
- canvas->use_matrix = old_use_matrix;
+void cdfSimLine(cdCtxCanvas* ctxcanvas, double x1, double y1, double x2, double y2)
+{
+ cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
+ cdfPoint poly[2];
+ poly[0].x = x1; poly[0].y = y1;
+ poly[1].x = x2; poly[1].y = y2;
+ canvas->cxFPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, 2);
}
-void cdrectSIM(cdCtxCanvas* ctxcanvas, int xmin, int xmax, int ymin, int ymax)
+void cdSimRect(cdCtxCanvas* ctxcanvas, int xmin, int xmax, int ymin, int ymax)
{
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
- cdPoint poly[5]; /* leave room of one more point */
+ cdPoint poly[5]; /* leave room for one more point */
poly[0].x = xmin; poly[0].y = ymin;
poly[1].x = xmin; poly[1].y = ymax;
poly[2].x = xmax; poly[2].y = ymax;
@@ -47,59 +42,42 @@ void cdrectSIM(cdCtxCanvas* ctxcanvas, int xmin, int xmax, int ymin, int ymax)
canvas->cxPoly(canvas->ctxcanvas, CD_CLOSED_LINES, poly, 4);
}
-void cdboxSIM(cdCtxCanvas* ctxcanvas, int xmin, int xmax, int ymin, int ymax)
+void cdfSimRect(cdCtxCanvas *ctxcanvas, double xmin, double xmax, double ymin, double ymax)
{
+ /* can be used only by drivers that implement cxFPoly */
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
-
- if (canvas->use_matrix)
- {
- cdPoint poly[5]; /* leave room of one more point */
- poly[0].x = xmin; poly[0].y = ymin;
- poly[1].x = xmin; poly[1].y = ymax;
- poly[2].x = xmax; poly[2].y = ymax;
- poly[3].x = xmax; poly[3].y = ymin;
- canvas->cxPoly(canvas->ctxcanvas, CD_FILL, poly, 4);
- }
- else
- {
- cdSimulation* simulation = canvas->simulation;
- int y;
-
- /* must set line attributes here, because fill simulation use cxLine and cxPixel */
- int old_line_style = cdCanvasLineStyle(canvas, CD_CONTINUOUS);
- int old_line_width = cdCanvasLineWidth(canvas, 1);
-
- for(y=ymin;y<=ymax;y++)
- simFillHorizLine(simulation, xmin, y, xmax);
-
- cdCanvasLineStyle(canvas, old_line_style);
- cdCanvasLineWidth(canvas, old_line_width);
- }
+ cdfPoint poly[5]; /* leave room for one more point */
+ poly[0].x = xmin; poly[0].y = ymin;
+ poly[1].x = xmin; poly[1].y = ymax;
+ poly[2].x = xmax; poly[2].y = ymax;
+ poly[3].x = xmax; poly[3].y = ymin;
+ canvas->cxFPoly(canvas->ctxcanvas, CD_CLOSED_LINES, poly, 4);
}
-void cdfSimBox(cdCtxCanvas *ctxcanvas, double xmin, double xmax, double ymin, double ymax)
+void cdSimBox(cdCtxCanvas* ctxcanvas, int xmin, int xmax, int ymin, int ymax)
{
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
- cdfPoint poly[5]; /* leave room of one more point */
+ cdPoint poly[5]; /* leave room for one more point */
poly[0].x = xmin; poly[0].y = ymin;
poly[1].x = xmin; poly[1].y = ymax;
poly[2].x = xmax; poly[2].y = ymax;
poly[3].x = xmax; poly[3].y = ymin;
- canvas->cxFPoly(canvas->ctxcanvas, CD_FILL, poly, 4);
+ canvas->cxPoly(canvas->ctxcanvas, CD_FILL, poly, 4);
}
-void cdfSimRect(cdCtxCanvas *ctxcanvas, double xmin, double xmax, double ymin, double ymax)
+void cdfSimBox(cdCtxCanvas *ctxcanvas, double xmin, double xmax, double ymin, double ymax)
{
+ /* can be used only by drivers that implement cxFPoly */
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
- cdfPoint poly[5]; /* leave room of one more point */
+ cdfPoint poly[5]; /* leave room for one more point */
poly[0].x = xmin; poly[0].y = ymin;
poly[1].x = xmin; poly[1].y = ymax;
poly[2].x = xmax; poly[2].y = ymax;
poly[3].x = xmax; poly[3].y = ymin;
- canvas->cxFPoly(canvas->ctxcanvas, CD_CLOSED_LINES, poly, 4);
+ canvas->cxFPoly(canvas->ctxcanvas, CD_FILL, poly, 4);
}
-int simCalcEllipseNumSegments(cdCanvas* canvas, int xc, int yc, int width, int height)
+int cdSimCalcEllipseNumSegments(cdCanvas* canvas, int xc, int yc, int width, int height)
{
int n, dx, dy, hd;
int w2 = width/2;
@@ -137,40 +115,47 @@ int simCalcEllipseNumSegments(cdCanvas* canvas, int xc, int yc, int width, int h
return n;
}
-void cdarcSIM(cdCtxCanvas* ctxcanvas, int xc, int yc, int width, int height, double angle1, double angle2)
+static void sFixAngles(cdCanvas* canvas, double *angle1, double *angle2)
+{
+ if (canvas->invert_yaxis)
+ {
+ double temp = 360 - *angle1; // TO CHECK
+ *angle1 = 360 - *angle2;
+ *angle2 = temp;
+
+ *angle1 *= CD_DEG2RAD;
+ *angle2 *= CD_DEG2RAD;
+ }
+ else
+ {
+ *angle1 *= CD_DEG2RAD;
+ *angle2 *= CD_DEG2RAD;
+ }
+}
+
+static cdPoint* sPolyAddArc(cdCanvas* canvas, cdPoint* poly, int *n, int xc, int yc, int width, int height, double angle1, double angle2)
{
- cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
double c, s, sx, sy, x, y, prev_x, prev_y;
double da;
- int i, yc2 = 2*yc, p = 0,
- last_xi_a = -65535,
- last_yi_a = -65535,
- last_xi_b = -65535,
- last_yi_b = -65535;
- cdPoint* poly = NULL;
+ int i, K, k, yc2 = 2*yc, p = 0, new_n;
/* number of segments of equivalent poligonal for a full ellipse */
- int n = simCalcEllipseNumSegments(canvas, xc, yc, width, height);
+ K = cdSimCalcEllipseNumSegments(canvas, xc, yc, width, height);
- /* Use special floating point anti-alias line draw when
- line_width==1, and NOT using cdlineSIM. */
- if (canvas->line_width > 1 || canvas->cxLine != cdlineSIM)
- {
- poly = (cdPoint*)malloc(sizeof(cdPoint)*(n+1)); /* n+1 points */
- if (!poly) return;
- }
+ sFixAngles(canvas, &angle1, &angle2);
/* number of segments for the arc */
- n = cdRound((fabs(angle2-angle1)*n)/360);
- if (n < 1) n = 1;
+ K = cdRound((fabs(angle2-angle1)*K)/(360*CD_DEG2RAD));
+ if (K < 1) K = 1;
- /* converts degrees into radians */
- angle1 *= CD_DEG2RAD;
- angle2 *= CD_DEG2RAD;
+ new_n = *n + K+1; /* add room for K+1 samples */
+ poly = (cdPoint*)realloc(poly, sizeof(cdPoint)*new_n);
+ if (!poly) return NULL;
+ i = *n;
/* generates arc points at origin with axis x and y */
- da = (angle2-angle1)/n;
+ da = (angle2-angle1)/K;
c = cos(da);
s = sin(da);
sx = -(width*s)/height;
@@ -180,100 +165,58 @@ void cdarcSIM(cdCtxCanvas* ctxcanvas, int xc, int yc, int width, int height, dou
y = (height/2.0f)*sin(angle1);
prev_x = x;
prev_y = y;
- if (poly)
- {
- poly[0].x = _cdRound(x)+xc;
- poly[0].y = _cdRound(y)+yc;
- if (canvas->invert_yaxis) /* must invert because of the angle orientation */
- poly[0].y = yc2 - poly[0].y;
+ poly[i].x = _cdRound(x)+xc;
+ poly[i].y = _cdRound(y)+yc;
- p = 1;
- }
- else
- simLineStyleNoReset = 1;
+ if (canvas->invert_yaxis) /* must invert because of the angle orientation */
+ poly[i].y = yc2 - poly[i].y;
- for (i = 1; i < n+1; i++) /* n+1 points */
+ p = i+1;
+ for (k = 1; k < K+1; k++)
{
x = c*prev_x + sx*prev_y;
y = sy*prev_x + c*prev_y;
- if (poly)
- {
- poly[p].x = _cdRound(x)+xc;
- poly[p].y = _cdRound(y)+yc;
-
- if (canvas->invert_yaxis) /* must invert because of the angle orientation */
- poly[p].y = yc2 - poly[p].y;
-
- if (poly[p-1].x != poly[p].x || poly[p-1].y != poly[p].y)
- p++;
- }
- else
- {
- int old_use_matrix = canvas->use_matrix;
- double x1 = prev_x+xc,
- y1 = prev_y+yc,
- x2 = x+xc,
- y2 = y+yc;
-
- if (canvas->use_matrix && !canvas->invert_yaxis)
- {
- cdfMatrixTransformPoint(canvas->matrix, x1, y1, &x1, &y1);
- cdfMatrixTransformPoint(canvas->matrix, x2, y2, &x2, &y2);
- }
-
- /* must disable transformation here, because line simulation use cxPixel */
- canvas->use_matrix = 0;
-
- if (canvas->invert_yaxis) /* must invert because of the angle orientation */
- {
- y1 = yc2 - y1;
- y2 = yc2 - y2;
- }
+ poly[p].x = _cdRound(x)+xc;
+ poly[p].y = _cdRound(y)+yc;
- simfLineThin(canvas, x1, y1, x2, y2, &last_xi_a, &last_yi_a, &last_xi_b, &last_yi_b);
+ if (canvas->invert_yaxis) /* must invert because of the angle orientation */
+ poly[p].y = yc2 - poly[p].y;
- canvas->use_matrix = old_use_matrix;
- }
+ if (poly[p-1].x != poly[p].x ||
+ poly[p-1].y != poly[p].y)
+ p++;
prev_x = x;
prev_y = y;
}
- if (poly)
- {
- canvas->cxPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, p);
- free(poly);
- }
- else
- simLineStyleNoReset = 0;
+ *n = new_n;
+ return poly;
}
-void cdfSimArc(cdCtxCanvas *ctxcanvas, double xc, double yc, double width, double height, double angle1, double angle2)
+static cdfPoint* sfPolyAddArc(cdCanvas* canvas, cdfPoint* poly, int *n, double xc, double yc, double width, double height, double angle1, double angle2)
{
- cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
double c, s, sx, sy, x, y, prev_x, prev_y, da;
- int i, p;
- cdfPoint* poly = NULL;
+ int i, k, p, new_n;
/* number of segments of equivalent poligonal for a full ellipse */
- int n = simCalcEllipseNumSegments(canvas, (int)xc, (int)yc, (int)width, (int)height);
+ int K = cdSimCalcEllipseNumSegments(canvas, (int)xc, (int)yc, (int)width, (int)height);
- poly = (cdfPoint*)malloc(sizeof(cdfPoint)*(n+1)); /* n+1 points */
- if (!poly) return;
+ sFixAngles(canvas, &angle1, &angle2);
/* number of segments for the arc */
- n = cdRound((fabs(angle2-angle1)*n)/360);
- if (n < 1) n = 1;
+ K = cdRound((fabs(angle2-angle1)*K)/(360*CD_DEG2RAD));
+ if (K < 1) K = 1;
- /* converts degrees into radians */
- angle1 *= CD_DEG2RAD;
- angle2 *= CD_DEG2RAD;
+ new_n = *n + K+1; /* add room for K+1 samples */
+ poly = (cdfPoint*)realloc(poly, sizeof(cdfPoint)*new_n);
+ if (!poly) return NULL;
+ i = *n;
- /* generates arc points at origin with axis x and y */
-
- da = (angle2-angle1)/n;
+ /* generates arc points at origin with axis x and y */
+ da = (angle2-angle1)/K;
c = cos(da);
s = sin(da);
sx = -(width*s)/height;
@@ -283,12 +226,12 @@ void cdfSimArc(cdCtxCanvas *ctxcanvas, double xc, double yc, double width, doubl
y = (height/2.0f)*sin(angle1);
prev_x = x;
prev_y = y;
- poly[0].x = x+xc;
- poly[0].y = y+yc;
+ poly[i].x = x+xc;
+ poly[i].y = y+yc;
- p = 1;
+ p = i+1;
- for (i = 1; i < n+1; i++) /* n+1 points */
+ for (k = 1; k < K+1; k++) /* K+1 points */
{
x = c*prev_x + sx*prev_y;
y = sy*prev_x + c*prev_y;
@@ -304,344 +247,1049 @@ void cdfSimArc(cdCtxCanvas *ctxcanvas, double xc, double yc, double width, doubl
prev_y = y;
}
- canvas->cxFPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, p);
- free(poly);
+ *n = new_n;
+ return poly;
}
-void cdfSimElipse(cdCtxCanvas* ctxcanvas, double xc, double yc, double width, double height, double angle1, double angle2, int sector)
+void cdSimArc(cdCtxCanvas* ctxcanvas, int xc, int yc, int width, int height, double angle1, double angle2)
{
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
- double c, s, sx, sy, x, y, prev_x, prev_y, da;
- int i, p;
- cdfPoint* poly;
+ int n;
+ cdPoint* poly = NULL;
- /* number of segments of equivalent poligonal for a full ellipse */
- int n = simCalcEllipseNumSegments(canvas, (int)xc, (int)yc, (int)width, (int)height);
+ if (canvas->line_width == 1 && canvas->cxFPoly)
+ {
+ cdfSimArc(ctxcanvas, (double)xc, (double)yc, (double)width, (double)height, angle1, angle2);
+ return;
+ }
- /* number of segments for the arc */
- n = cdRound(((angle2-angle1)*n)/360);
- if (n < 1) n = 1;
+ poly = sPolyAddArc(canvas, poly, &n, xc, yc, width, height, angle1, angle2);
- poly = (cdfPoint*)malloc(sizeof(cdfPoint)*(n+2+1)); /* n+1 points +1 center */
+ if (poly)
+ {
+ canvas->cxPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, n);
+ free(poly);
+ }
+}
- /* converts degrees into radians */
- angle1 *= CD_DEG2RAD;
- angle2 *= CD_DEG2RAD;
+void cdfSimArc(cdCtxCanvas *ctxcanvas, double xc, double yc, double width, double height, double angle1, double angle2)
+{
+ /* can be used only by drivers that implement cxFPoly */
+ cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
+ int n;
+ cdfPoint* poly = NULL;
- /* generates arc points at origin with axis x and y */
+ poly = sfPolyAddArc(canvas, poly, &n, xc, yc, width, height, angle1, angle2);
- da = (angle2-angle1)/n;
- c = cos(da);
- s = sin(da);
- sx = -(width*s)/height;
- sy = (height*s)/width;
+ if (poly)
+ {
+ canvas->cxFPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, n);
+ free(poly);
+ }
+}
- x = xc + (width/2.0)*cos(angle1);
- y = yc + (height/2.0)*sin(angle1);
- prev_x = x;
- prev_y = y;
+static void sElipse(cdCtxCanvas* ctxcanvas, int xc, int yc, int width, int height, double angle1, double angle2, int sector)
+{
+ cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
+ int n;
+ cdPoint* poly = NULL;
- poly[0].x = x;
- poly[0].y = y;
- p = 1;
+ poly = sPolyAddArc(canvas, poly, &n, xc, yc, width, height, angle1, angle2);
- for (i = 1; i < n+1; i++) /* n+1 points */
+ if (poly[n-1].x != poly[0].x ||
+ poly[n-1].y != poly[0].y)
{
- x = xc + c*(prev_x-xc) + sx*(prev_y-yc);
- y = yc + sy*(prev_x-xc) + c*(prev_y-yc);
-
- poly[p].x = x;
- poly[p].y = y;
+ n++;
+ poly = (cdPoint*)realloc(poly, sizeof(cdPoint)*n);
+ if (!poly) return;
- if (poly[p-1].x != poly[p].x || poly[p-1].y != poly[p].y)
- p++;
+ if (sector) /* cdSector */
+ {
+ /* add center */
+ poly[n-1].x = xc;
+ poly[n-1].y = yc;
+ }
+ else /* cdChord */
+ {
+ /* add initial point */
+ poly[n-1].x = poly[0].x;
+ poly[n-1].y = poly[0].y;
+ }
+ }
- prev_x = x;
- prev_y = y;
+ if (poly)
+ {
+ canvas->cxPoly(canvas->ctxcanvas, CD_FILL, poly, n);
+ free(poly);
}
+}
- if (poly[p-1].x != poly[0].x || poly[p-1].y != poly[0].y)
+static void sfElipse(cdCtxCanvas* ctxcanvas, double xc, double yc, double width, double height, double angle1, double angle2, int sector)
+{
+ /* can be used only by drivers that implement cxFPoly */
+ cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
+ int n;
+ cdfPoint* poly = NULL;
+
+ poly = sfPolyAddArc(canvas, poly, &n, xc, yc, width, height, angle1, angle2);
+
+ if (poly[n-1].x != poly[0].x ||
+ poly[n-1].y != poly[0].y)
{
+ n++;
+ poly = (cdfPoint*)realloc(poly, sizeof(cdfPoint)*n);
+ if (!poly) return;
+
if (sector) /* cdSector */
{
/* add center */
- poly[p].x = xc;
- poly[p].y = yc;
+ poly[n-1].x = xc;
+ poly[n-1].y = yc;
}
else /* cdChord */
{
/* add initial point */
- poly[p].x = poly[0].x;
- poly[p].y = poly[0].y;
+ poly[n-1].x = poly[0].x;
+ poly[n-1].y = poly[0].y;
}
- p++;
}
- canvas->cxFPoly(canvas->ctxcanvas, CD_FILL, poly, p);
- free(poly);
+ if (poly)
+ {
+ canvas->cxFPoly(canvas->ctxcanvas, CD_FILL, poly, n);
+ free(poly);
+ }
}
-static void cdSimElipse(cdCtxCanvas* ctxcanvas, int xc, int yc, int width, int height, double angle1, double angle2, int sector)
+void cdSimSector(cdCtxCanvas* ctxcanvas, int xc, int yc, int width, int height, double angle1, double angle2)
{
- cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
- float c, s, sx, sy, x, y, prev_x, prev_y;
- double da;
- int i, p, yc2 = 2*yc;
- cdPoint* poly;
+ sElipse(ctxcanvas, xc, yc, width, height, angle1, angle2, 1);
+}
- /* number of segments of equivalent poligonal for a full ellipse */
- int n = simCalcEllipseNumSegments(canvas, xc, yc, width, height);
+void cdSimChord(cdCtxCanvas* ctxcanvas, int xc, int yc, int width, int height, double angle1, double angle2)
+{
+ sElipse(ctxcanvas, xc, yc, width, height, angle1, angle2, 0);
+}
- /* number of segments for the arc */
- n = cdRound(((angle2-angle1)*n)/360);
- if (n < 1) n = 1;
+void cdfSimSector(cdCtxCanvas *ctxcanvas, double xc, double yc, double w, double h, double a1, double a2)
+{
+ sfElipse(ctxcanvas, xc, yc, w, h, a1, a2, 0);
+}
- poly = (cdPoint*)malloc(sizeof(cdPoint)*(n+2+1)); /* n+1 points +1 center */
+void cdfSimChord(cdCtxCanvas *ctxcanvas, double xc, double yc, double w, double h, double a1, double a2)
+{
+ sfElipse(ctxcanvas, xc, yc, w, h, a1, a2, 0);
+}
- /* converts degrees into radians */
- angle1 *= CD_DEG2RAD;
- angle2 *= CD_DEG2RAD;
+/**************************************************************/
+/* Quick and Simple Bezier Curve Drawing --- Robert D. Miller */
+/* Graphics GEMS V */
+/**************************************************************/
- /* generates arc points at origin with axis x and y */
+/* Setup Bezier coefficient array once for each control polygon.
+ */
+static void sBezierForm(cdPoint start, const cdPoint* p, cdfPoint* c)
+{
+ int k;
+ static int choose[4] = {1, 3, 3, 1};
+ for (k = 0; k < 4; k++)
+ {
+ if (k == 0)
+ {
+ c[k].x = start.x * choose[k];
+ c[k].y = start.y * choose[k];
+ }
+ else
+ {
+ c[k].x = p[k-1].x * choose[k];
+ c[k].y = p[k-1].y * choose[k];
+ }
+ }
+}
- da = (angle2-angle1)/n;
- c = (float)cos(da);
- s = (float)sin(da);
- sx = -(width*s)/height;
- sy = (height*s)/width;
+static void sfBezierForm(cdfPoint start, const cdfPoint* p, cdfPoint* c)
+{
+ int k;
+ static int choose[4] = {1, 3, 3, 1};
+ for (k = 0; k < 4; k++)
+ {
+ if (k == 0)
+ {
+ c[k].x = start.x * choose[k];
+ c[k].y = start.y * choose[k];
+ }
+ else
+ {
+ c[k].x = p[k-1].x * choose[k];
+ c[k].y = p[k-1].y * choose[k];
+ }
+ }
+}
- x = xc + (width/2.0f)*(float)cos(angle1);
- y = yc + (height/2.0f)*(float)sin(angle1);
- prev_x = x;
- prev_y = y;
+/* Return Point pt(t), t <= 0 <= 1 from C.
+ * sBezierForm must be called once for any given control polygon.
+ */
+static void sBezierCurve(const cdfPoint* c, cdfPoint *pt, double t)
+{
+ int k;
+ double t1, tt, u;
+ cdfPoint b[4];
- poly[0].x = _cdRound(x);
- poly[0].y = _cdRound(y);
- if (canvas->invert_yaxis)
- poly[0].y = yc2 - poly[0].y;
- p = 1;
+ u = t;
- for (i = 1; i < n+1; i++) /* n+1 points */
+ b[0].x = c[0].x;
+ b[0].y = c[0].y;
+ for(k = 1; k < 4; k++)
{
- x = xc + c*(prev_x-xc) + sx*(prev_y-yc);
- y = yc + sy*(prev_x-xc) + c*(prev_y-yc);
+ b[k].x = c[k].x * u;
+ b[k].y = c[k].y * u;
+ u =u*t;
+ }
- poly[p].x = _cdRound(x);
- poly[p].y = _cdRound(y);
+ pt->x = b[3].x;
+ pt->y = b[3].y;
+ t1 = 1-t;
+ tt = t1;
+ for(k = 2; k >= 0; k--)
+ {
+ pt->x += b[k].x * tt;
+ pt->y += b[k].y * tt;
+ tt =tt*t1;
+ }
+}
- if (canvas->invert_yaxis)
- poly[p].y = yc2 - poly[p].y;
+static int sBezierNumSegments(cdCanvas* canvas, cdPoint start, const cdPoint* p)
+{
+ int i, K, dx, dy, d,
+ xmax = start.x,
+ ymax = start.y,
+ xmin = start.x,
+ ymin = start.y;
- if (poly[p-1].x != poly[p].x || poly[p-1].y != poly[p].y)
- p++;
+ for (i = 1; i < 4; i++)
+ {
+ if (p[i].x > xmax)
+ xmax = p[i].x;
+ if (p[i].y > ymax)
+ ymax = p[i].y;
+ if (p[i].x < xmin)
+ xmin = p[i].x;
+ if (p[i].y < ymin)
+ ymin = p[i].y;
+ }
- prev_x = x;
- prev_y = y;
+ if (canvas->use_matrix)
+ {
+ cdMatrixTransformPoint(canvas->matrix, xmin, ymin, &xmin, &ymin);
+ cdMatrixTransformPoint(canvas->matrix, xmax, ymax, &xmax, &ymax);
}
- if (poly[p-1].x != poly[0].x || poly[p-1].y != poly[0].y)
+ /* diagonal of the bouding box */
+ dx = (xmax-xmin);
+ dy = (ymax-ymin);
+ d = (int)(sqrt(dx*dx + dy*dy));
+ K = d / 8;
+ if (K < 8) K = 8;
+ return K;
+}
+
+static int sfBezierNumSegments(cdCanvas* canvas, cdfPoint start, const cdfPoint* p)
+{
+ int i, K, d;
+ double dx, dy,
+ xmax = start.x,
+ ymax = start.y,
+ xmin = start.x,
+ ymin = start.y;
+
+ for (i = 1; i < 4; i++)
{
- if (sector) /* cdSector */
+ if (p[i].x > xmax)
+ xmax = p[i].x;
+ if (p[i].y > ymax)
+ ymax = p[i].y;
+ if (p[i].x < xmin)
+ xmin = p[i].x;
+ if (p[i].y < ymin)
+ ymin = p[i].y;
+ }
+
+ if (canvas->use_matrix)
+ {
+ cdfMatrixTransformPoint(canvas->matrix, xmin, ymin, &xmin, &ymin);
+ cdfMatrixTransformPoint(canvas->matrix, xmax, ymax, &xmax, &ymax);
+ }
+
+ /* diagonal of the bouding box */
+ dx = (xmax-xmin);
+ dy = (ymax-ymin);
+ d = (int)(sqrt(dx*dx + dy*dy));
+ K = d / 8;
+ if (K < 8) K = 8;
+ return K;
+}
+
+static cdPoint* sPolyAddBezier(cdCanvas* canvas, cdPoint* poly, int *n, cdPoint start, const cdPoint* points)
+{
+ int k, K, new_n, i;
+ cdfPoint pt;
+ cdfPoint bezier_control[4];
+
+ sBezierForm(start, points, bezier_control);
+ K = sBezierNumSegments(canvas, start, points);
+
+ new_n = *n + K+1; /* add room for K+1 samples */
+ poly = realloc(poly, sizeof(cdPoint)*new_n);
+ if (!poly) return NULL;
+ i = *n;
+
+ /* first segment */
+ sBezierCurve(bezier_control, &pt, 0);
+
+ poly[i].x = _cdRound(pt.x);
+ poly[i].y = _cdRound(pt.y);
+
+ for(k = 1; k < K+1; k++)
+ {
+ sBezierCurve(bezier_control, &pt, (double)k/(double)K);
+
+ poly[i+k].x = _cdRound(pt.x);
+ poly[i+k].y = _cdRound(pt.y);
+ }
+
+ *n = new_n;
+ return poly;
+}
+
+static cdfPoint* sPolyFAddBezier(cdCanvas* canvas, cdfPoint* poly, int *n, cdPoint start, const cdPoint* points)
+{
+ int k, K, new_n, i;
+ cdfPoint pt;
+ cdfPoint bezier_control[4];
+
+ sBezierForm(start, points, bezier_control);
+ K = sBezierNumSegments(canvas, start, points);
+
+ new_n = *n + K+1; /* add room for K+1 samples */
+ poly = realloc(poly, sizeof(cdfPoint)*new_n);
+ if (!poly) return NULL;
+ i = *n;
+
+ /* first segment */
+ sBezierCurve(bezier_control, &pt, 0);
+
+ poly[i] = pt;
+
+ for(k = 1; k < K+1; k++)
+ {
+ sBezierCurve(bezier_control, &pt, (double)k/(double)K);
+ poly[i+k] = pt;
+ }
+
+ *n = new_n;
+ return poly;
+}
+
+static cdfPoint* sfPolyAddBezier(cdCanvas* canvas, cdfPoint* poly, int *n, cdfPoint start, const cdfPoint* points)
+{
+ int k, K, new_n, i;
+ cdfPoint pt;
+ cdfPoint bezier_control[4];
+
+ sfBezierForm(start, points, bezier_control);
+ K = sfBezierNumSegments(canvas, start, points);
+
+ new_n = *n + K+1; /* add room for K+1 samples */
+ poly = realloc(poly, sizeof(cdfPoint)*new_n);
+ if (!poly) return NULL;
+ i = *n;
+
+ /* first segment */
+ sBezierCurve(bezier_control, &pt, 0);
+
+ poly[i] = pt;
+
+ for(k = 1; k < K+1; k++)
+ {
+ sBezierCurve(bezier_control, &pt, (double)k/(double)K);
+ poly[i+k] = pt;
+ }
+
+ *n = new_n;
+ return poly;
+}
+
+static void sPolyFBezier(cdCanvas* canvas, const cdPoint* points, int n)
+{
+ int i = 0, poly_n = 0;
+ cdfPoint* fpoly = NULL;
+
+ n--; /* first n is 4 */
+ while (n >= 3)
+ {
+ fpoly = sPolyFAddBezier(canvas, fpoly, &poly_n, points[i], points+i+1);
+ n -= 3; i += 3;
+ }
+
+ if (fpoly)
+ {
+ canvas->cxFPoly(canvas->ctxcanvas, CD_OPEN_LINES, fpoly, poly_n);
+ free(fpoly);
+ }
+}
+
+void cdSimPolyBezier(cdCanvas* canvas, const cdPoint* points, int n)
+{
+ int i = 0, poly_n = 0;
+ cdPoint* poly = NULL;
+
+ if (canvas->line_width == 1 && canvas->cxFPoly)
+ {
+ sPolyFBezier(canvas, points, n);
+ return;
+ }
+
+ n--; /* first n is 4 */
+ while (n >= 3)
+ {
+ poly = sPolyAddBezier(canvas, poly, &poly_n, points[i], points+i+1);
+ n -= 3; i += 3;
+ }
+
+ if (poly)
+ {
+ canvas->cxPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, poly_n);
+ free(poly);
+ }
+}
+
+void cdfSimPolyBezier(cdCanvas* canvas, const cdfPoint* points, int n)
+{
+ /* can be used only by drivers that implement cxFPoly */
+ int i = 0, poly_n = 0;
+ cdfPoint* poly = NULL;
+
+ n--; /* first n is 4 */
+ while (n >= 3)
+ {
+ poly = sfPolyAddBezier(canvas, poly, &poly_n, points[i], points+i+1);
+ n -= 3; i += 3;
+ }
+
+ if (poly)
+ {
+ canvas->cxFPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, poly_n);
+ free(poly);
+ }
+}
+
+static cdPoint* sPolyAddLine(cdPoint* poly, int *n, cdPoint p1, cdPoint p2)
+{
+ int new_n, i;
+
+ new_n = *n + 2;
+ poly = realloc(poly, sizeof(cdPoint)*new_n);
+ if (!poly) return NULL;
+ i = *n;
+
+ poly[i] = p1;
+ poly[i+1] = p2;
+
+ *n = new_n;
+ return poly;
+}
+
+static cdfPoint* sfPolyAddLine(cdfPoint* poly, int *n, cdfPoint p1, cdfPoint p2)
+{
+ int new_n, i;
+
+ new_n = *n + 2;
+ poly = realloc(poly, sizeof(cdfPoint)*new_n);
+ if (!poly) return NULL;
+ i = *n;
+
+ poly[i] = p1;
+ poly[i+1] = p2;
+
+ *n = new_n;
+ return poly;
+}
+
+void cdfSimPolyPath(cdCanvas* canvas, const cdfPoint* poly, int n)
+{
+ int p, i, current_set = 0, path_poly_n;
+ cdfPoint current;
+ cdfPoint* path_poly;
+
+ current.x = 0;
+ current.y = 0;
+ current_set = 0;
+
+ /* starts a new path */
+ path_poly = NULL;
+ path_poly_n = 0;
+
+ i = 0;
+ for (p=0; p<canvas->path_n; p++)
+ {
+ switch(canvas->path[p])
{
- /* add center */
- poly[p].x = xc;
- poly[p].y = yc;
+ case CD_PATH_NEW:
+ if (path_poly)
+ free(path_poly);
+ path_poly = NULL;
+ path_poly_n = 0;
+ current_set = 0;
+ break;
+ case CD_PATH_MOVETO:
+ if (i+1 > n) break;
+ current = poly[i];
+ current_set = 1;
+ i++;
+ break;
+ case CD_PATH_LINETO:
+ if (i+1 > n) break;
+ path_poly = sfPolyAddLine(path_poly, &path_poly_n, current, poly[i]);
+ current = poly[i];
+ current_set = 1;
+ i++;
+ break;
+ case CD_PATH_ARC:
+ {
+ double xc, yc, w, h;
+ double a1, a2;
+
+ if (i+3 > n) break;
+
+ xc = poly[i].x,
+ yc = poly[i].y,
+ w = poly[i+1].x,
+ h = poly[i+1].y,
+ a1 = poly[i+2].x/1000.0,
+ a2 = poly[i+2].y/1000.0;
+
+ if (current_set)
+ {
+ cdfPoint start_angle;
+
+ if (canvas->invert_yaxis)
+ {
+ start_angle.x = xc + cdRound(w * cos(CD_DEG2RAD * a1) / 2.0);
+ start_angle.y = yc - cdRound(h * sin(CD_DEG2RAD * a1) / 2.0);
+ }
+ else
+ {
+ start_angle.x = xc + cdRound(w * cos(CD_DEG2RAD * a2) / 2.0);
+ start_angle.y = yc + cdRound(h * sin(CD_DEG2RAD * a2) / 2.0);
+ }
+
+ path_poly = sfPolyAddLine(path_poly, &path_poly_n, current, start_angle);
+ }
+
+ path_poly = sfPolyAddArc(canvas, path_poly, &path_poly_n, xc, yc, w, h, a1, a2);
+
+ current = path_poly[path_poly_n-1];
+ current_set = 1;
+
+ i += 3;
+ }
+ break;
+ case CD_PATH_CURVETO:
+ if (i+3 > n) break;
+ if (!current_set)
+ {
+ current.x = poly[i].x;
+ current.y = poly[i].y;
+ }
+ path_poly = sfPolyAddBezier(canvas, path_poly, &path_poly_n, current, poly+i);
+ current.x = poly[i+2].x;
+ current.y = poly[i+2].y;
+ current_set = 1;
+ i += 3;
+ break;
+ case CD_PATH_CLOSE:
+ if (path_poly[path_poly_n-1].x != path_poly[0].x ||
+ path_poly[path_poly_n-1].y != path_poly[0].y)
+ {
+ path_poly_n++;
+ path_poly = (cdfPoint*)realloc(path_poly, sizeof(cdfPoint)*path_poly_n);
+ if (!path_poly) return;
+
+ /* add initial point */
+ path_poly[path_poly_n-1].x = path_poly[0].x;
+ path_poly[path_poly_n-1].y = path_poly[0].y;
+ }
+ break;
+ case CD_PATH_FILL:
+ if (poly)
+ canvas->cxFPoly(canvas->ctxcanvas, CD_FILL, path_poly, path_poly_n);
+ break;
+ case CD_PATH_STROKE:
+ if (poly)
+ canvas->cxFPoly(canvas->ctxcanvas, CD_OPEN_LINES, path_poly, path_poly_n);
+ break;
+ case CD_PATH_FILLSTROKE:
+ if (poly)
+ {
+ canvas->cxFPoly(canvas->ctxcanvas, CD_FILL, path_poly, path_poly_n);
+ canvas->cxFPoly(canvas->ctxcanvas, CD_OPEN_LINES, path_poly, path_poly_n);
+ }
+ break;
+ case CD_PATH_CLIP:
+ if (poly)
+ canvas->cxFPoly(canvas->ctxcanvas, CD_CLIP, path_poly, path_poly_n);
+ break;
}
- else /* cdChord */
+ }
+
+ if (path_poly)
+ free(path_poly);
+}
+
+void cdSimPolyPath(cdCanvas* canvas, const cdPoint* poly, int n)
+{
+ int p, i, current_set = 0, path_poly_n;
+ cdPoint current;
+ cdPoint* path_poly;
+
+ current.x = 0;
+ current.y = 0;
+ current_set = 0;
+
+ /* starts a new path */
+ path_poly = NULL;
+ path_poly_n = 0;
+
+ i = 0;
+ for (p=0; p<canvas->path_n; p++)
+ {
+ switch(canvas->path[p])
{
- /* add initial point */
- poly[p].x = poly[0].x;
- poly[p].y = poly[0].y;
+ case CD_PATH_NEW:
+ if (path_poly)
+ free(path_poly);
+ path_poly = NULL;
+ path_poly_n = 0;
+ current_set = 0;
+ break;
+ case CD_PATH_MOVETO:
+ if (i+1 > n) break;
+ current = poly[i];
+ current_set = 1;
+ i++;
+ break;
+ case CD_PATH_LINETO:
+ if (i+1 > n) break;
+ path_poly = sPolyAddLine(path_poly, &path_poly_n, current, poly[i]);
+ current = poly[i];
+ current_set = 1;
+ i++;
+ break;
+ case CD_PATH_ARC:
+ {
+ int xc, yc, w, h;
+ double a1, a2;
+
+ if (i+3 > n) break;
+
+ xc = poly[i].x,
+ yc = poly[i].y,
+ w = poly[i+1].x,
+ h = poly[i+1].y,
+ a1 = poly[i+2].x/1000.0,
+ a2 = poly[i+2].y/1000.0;
+
+ if (current_set)
+ {
+ cdPoint start_angle;
+
+ if (canvas->invert_yaxis)
+ {
+ start_angle.x = xc + cdRound(w * cos(CD_DEG2RAD * a1) / 2.0);
+ start_angle.y = yc - cdRound(h * sin(CD_DEG2RAD * a1) / 2.0);
+ }
+ else
+ {
+ start_angle.x = xc + cdRound(w * cos(CD_DEG2RAD * a2) / 2.0);
+ start_angle.y = yc + cdRound(h * sin(CD_DEG2RAD * a2) / 2.0);
+ }
+
+ path_poly = sPolyAddLine(path_poly, &path_poly_n, current, start_angle);
+ }
+
+ path_poly = sPolyAddArc(canvas, path_poly, &path_poly_n, xc, yc, w, h, a1, a2);
+
+ current = path_poly[path_poly_n-1];
+ current_set = 1;
+
+ i += 3;
+ }
+ break;
+ case CD_PATH_CURVETO:
+ if (i+3 > n) break;
+ if (!current_set)
+ {
+ current.x = poly[i].x;
+ current.y = poly[i].y;
+ }
+ path_poly = sPolyAddBezier(canvas, path_poly, &path_poly_n, current, poly+i);
+ current.x = poly[i+2].x;
+ current.y = poly[i+2].y;
+ current_set = 1;
+ i += 3;
+ break;
+ case CD_PATH_CLOSE:
+ if (path_poly[path_poly_n-1].x != path_poly[0].x ||
+ path_poly[path_poly_n-1].y != path_poly[0].y)
+ {
+ path_poly_n++;
+ path_poly = (cdPoint*)realloc(path_poly, sizeof(cdPoint)*path_poly_n);
+ if (!path_poly) return;
+
+ /* add initial point */
+ path_poly[path_poly_n-1].x = path_poly[0].x;
+ path_poly[path_poly_n-1].y = path_poly[0].y;
+ }
+ break;
+ case CD_PATH_FILL:
+ if (poly)
+ canvas->cxPoly(canvas->ctxcanvas, CD_FILL, path_poly, path_poly_n);
+ break;
+ case CD_PATH_STROKE:
+ if (poly)
+ canvas->cxPoly(canvas->ctxcanvas, CD_OPEN_LINES, path_poly, path_poly_n);
+ break;
+ case CD_PATH_FILLSTROKE:
+ if (poly)
+ {
+ canvas->cxPoly(canvas->ctxcanvas, CD_FILL, path_poly, path_poly_n);
+ canvas->cxPoly(canvas->ctxcanvas, CD_OPEN_LINES, path_poly, path_poly_n);
+ }
+ break;
+ case CD_PATH_CLIP:
+ if (poly)
+ canvas->cxPoly(canvas->ctxcanvas, CD_CLIP, path_poly, path_poly_n);
+ break;
}
- p++;
- }
-
- canvas->cxPoly(canvas->ctxcanvas, CD_FILL, poly, p);
-
- free(poly);
-}
-
-void cdsectorSIM(cdCtxCanvas* ctxcanvas, int xc, int yc, int width, int height, double angle1, double angle2)
-{
- cdSimElipse(ctxcanvas, xc, yc, width, height, angle1, angle2, 1);
-}
-
-void cdchordSIM(cdCtxCanvas* ctxcanvas, int xc, int yc, int width, int height, double angle1, double angle2)
-{
- cdSimElipse(ctxcanvas, xc, yc, width, height, angle1, angle2, 0);
-}
-
-void cdfSimPolyPath(cdCtxCanvas* ctxcanvas, cdfPoint* poly, int n)
-{
-}
-
-void cdSimPolyPath(cdCtxCanvas* ctxcanvas, cdPoint* poly, int n)
-{
-// int p, i, current_x = 0, current_y = 0, current_set = 0;
-//
-// i = 0;
-// for (p=0; p<ctxcanvas->canvas->path_n; p++)
-// {
-// switch(ctxcanvas->canvas->path[p])
-// {
-// case CD_PATH_NEW:
-// current_set = 0;
-// break;
-// case CD_PATH_MOVETO:
-// if (i+1 > n) break;
-// current_x = poly[i].x;
-// current_y = poly[i].y;
-// current_set = 1;
-// i++;
-// break;
-// case CD_PATH_LINETO:
-// if (i+1 > n) break;
-// if (current_set)
-// graphics_path->AddLine(current_x, current_y, poly[i].x, poly[i].y);
-// current_x = poly[i].x;
-// current_y = poly[i].y;
-// current_set = 1;
-// i++;
-// break;
-// case CD_PATH_ARC:
-// {
-// int xc, yc, w, h;
-// double a1, a2;
-//
-// if (i+3 > n) break;
-//
-// xc = poly[i].x,
-// yc = poly[i].y,
-// w = poly[i+1].x,
-// h = poly[i+1].y,
-// a1 = poly[i+2].x/1000.0,
-// a2 = poly[i+2].y/1000.0;
-//
-// if (current_set)
-// {
-// int StartX, StartY;
-//
-// if (ctxcanvas->canvas->invert_yaxis)
-// {
-// StartX = xc + cdRound(w * cos(CD_DEG2RAD * a1) / 2.0);
-// StartY = yc - cdRound(h * sin(CD_DEG2RAD * a1) / 2.0);
-// }
-// else
-// {
-// StartX = xc + cdRound(w * cos(CD_DEG2RAD * a2) / 2.0);
-// StartY = yc + cdRound(h * sin(CD_DEG2RAD * a2) / 2.0);
-// }
-//
-// graphics_path->AddLine(current_x, current_y, StartX, StartY);
-// }
-//
-// Rect rect(xc - w/2, yc - h/2, w, h);
-// if (a1 == 0 && a2 == 360)
-// graphics_path->AddEllipse(rect);
-// else
-// {
-// cdwpFixAngles(ctxcanvas, &a1, &a2);
-// graphics_path->AddArc(rect, (REAL)a1, (REAL)(a2-a1));
-// }
-//
-// graphics_path->GetLastPoint(&lastPoint);
-// current_x = (int)lastPoint.X;
-// current_y = (int)lastPoint.Y;
-// current_set = 1;
-//
-// i += 3;
-// }
-// break;
-// case CD_PATH_CURVETO:
-// if (i+3 > n) break;
-// if (!current_set)
-// {
-// current_x = poly[i].x;
-// current_y = poly[i].y;
-// }
-// graphics_path->AddBezier(current_x, current_y, poly[i].x, poly[i].y, poly[i+1].x, poly[i+1].y, poly[i+2].x, poly[i+2].y);
-// graphics_path->GetLastPoint(&lastPoint);
-// current_x = (int)lastPoint.X;
-// current_y = (int)lastPoint.Y;
-// current_set = 1;
-// i += 3;
-// break;
-// case CD_PATH_CLOSE:
-// graphics_path->CloseFigure();
-// break;
-// case CD_PATH_FILL:
-// ctxcanvas->graphics->FillPath(ctxcanvas->fillBrush, graphics_path);
-// break;
-// case CD_PATH_STROKE:
-// ctxcanvas->graphics->DrawPath(ctxcanvas->linePen, graphics_path);
-// break;
-// case CD_PATH_FILLSTROKE:
-// ctxcanvas->graphics->FillPath(ctxcanvas->fillBrush, graphics_path);
-// ctxcanvas->graphics->DrawPath(ctxcanvas->linePen, graphics_path);
-// break;
-// case CD_PATH_CLIP:
-// ctxcanvas->graphics->SetClip(graphics_path, CombineModeIntersect);
-// break;
-// }
-// }
-//
-// delete graphics_path;
-// break;
-}
-
-void cdpolySIM(cdCtxCanvas* ctxcanvas, int mode, cdPoint* poly, int n)
+ }
+
+ if (path_poly)
+ free(path_poly);
+}
+
+/************************************************************************/
+
+void cdSimPoly(cdCtxCanvas* ctxcanvas, int mode, cdPoint* poly, int n)
{
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
- int i, reset = 1;
switch(mode)
{
case CD_CLOSED_LINES:
- poly[n] = poly[0];
+ poly[n] = poly[0]; /* can do that because poly is internal of the CD */
n++;
/* continue */
case CD_OPEN_LINES:
- if (simLineStyleNoReset) /* Bezier simulation use several poly */
- {
- reset = 0;
- simLineStyleNoReset = 1;
- }
- for (i = 0; i< n - 1; i++)
- canvas->cxLine(canvas->ctxcanvas, poly[i].x, poly[i].y, poly[i+1].x, poly[i+1].y);
- if (reset) simLineStyleNoReset = 0;
+ cdSimPolyLine(canvas, poly, n);
break;
case CD_BEZIER:
- simLineStyleNoReset = 1;
cdSimPolyBezier(canvas, poly, n);
- simLineStyleNoReset = 0;
break;
case CD_PATH:
- simLineStyleNoReset = 1;
cdSimPolyPath(canvas, poly, n);
- simLineStyleNoReset = 0;
break;
case CD_FILL:
+ cdSimPolyFill(canvas, poly, n);
+ break;
+ }
+}
+
+void cdSimMark(cdCanvas* canvas, int x, int y)
+{
+ int oldinteriorstyle = canvas->interior_style;
+ int oldlinestyle = canvas->line_style;
+ int oldlinewidth = canvas->line_width;
+ int size = canvas->mark_size;
+ int half_size = size/2;
+ int bottom = y-half_size;
+ int top = y+half_size;
+ int left = x-half_size;
+ int right = x+half_size;
+
+ if (canvas->interior_style != CD_SOLID &&
+ (canvas->mark_type == CD_CIRCLE ||
+ canvas->mark_type == CD_BOX ||
+ canvas->mark_type == CD_DIAMOND))
+ cdCanvasInteriorStyle(canvas, CD_SOLID);
+
+ if (canvas->line_style != CD_CONTINUOUS &&
+ (canvas->mark_type == CD_STAR ||
+ canvas->mark_type == CD_PLUS ||
+ canvas->mark_type == CD_X ||
+ canvas->mark_type == CD_HOLLOW_BOX ||
+ canvas->mark_type == CD_HOLLOW_CIRCLE ||
+ canvas->mark_type == CD_HOLLOW_DIAMOND))
+ cdCanvasLineStyle(canvas, CD_CONTINUOUS);
+
+ if (canvas->line_width != 1 &&
+ (canvas->mark_type == CD_STAR ||
+ canvas->mark_type == CD_PLUS ||
+ canvas->mark_type == CD_X ||
+ canvas->mark_type == CD_HOLLOW_BOX ||
+ canvas->mark_type == CD_HOLLOW_CIRCLE ||
+ canvas->mark_type == CD_HOLLOW_DIAMOND))
+ cdCanvasLineWidth(canvas, 1);
+
+ switch (canvas->mark_type)
+ {
+ case CD_STAR:
+ canvas->cxLine(canvas->ctxcanvas, left, bottom, right, top);
+ canvas->cxLine(canvas->ctxcanvas, left, top, right, bottom);
+ /* continue */
+ case CD_PLUS:
+ canvas->cxLine(canvas->ctxcanvas, left, y, right, y);
+ canvas->cxLine(canvas->ctxcanvas, x, bottom, x, top);
+ break;
+ case CD_X:
+ canvas->cxLine(canvas->ctxcanvas, left, bottom, right, top);
+ canvas->cxLine(canvas->ctxcanvas, left, top, right, bottom);
+ break;
+ case CD_HOLLOW_CIRCLE:
+ canvas->cxArc(canvas->ctxcanvas, x, y, size, size, 0, 360);
+ break;
+ case CD_HOLLOW_BOX:
+ canvas->cxRect(canvas->ctxcanvas, left, right, bottom, top);
+ break;
+ case CD_CIRCLE:
+ canvas->cxSector(canvas->ctxcanvas, x, y, size, size, 0, 360);
+ break;
+ case CD_BOX:
+ canvas->cxBox(canvas->ctxcanvas, left, right, bottom, top);
+ break;
+ case CD_HOLLOW_DIAMOND:
+ case CD_DIAMOND:
{
- /* must set line attributes here, because fill simulation use cxLine */
- int oldwidth = cdCanvasLineWidth(canvas, 1);
- int oldstyle = cdCanvasLineStyle(canvas, CD_CONTINUOUS);
- int old_use_matrix = canvas->use_matrix;
+ cdPoint poly[5]; /* leave room for one more point */
+ poly[0].x = left;
+ poly[0].y = y;
+ poly[1].x = x;
+ poly[1].y = top;
+ poly[2].x = right;
+ poly[2].y = y;
+ poly[3].x = x;
+ poly[3].y = bottom;
+
+ if (canvas->mark_type == CD_DIAMOND)
+ canvas->cxPoly(canvas->ctxcanvas, CD_FILL, poly, 4);
+ else
+ canvas->cxPoly(canvas->ctxcanvas, CD_CLOSED_LINES, poly, 4);
+ }
+ break;
+ }
- if (canvas->use_matrix && !canvas->invert_yaxis)
- {
- for(i = 0; i < n; i++)
- cdMatrixTransformPoint(canvas->matrix, poly[i].x, poly[i].y, &poly[i].x, &poly[i].y);
- }
+ if (canvas->interior_style != oldinteriorstyle &&
+ (canvas->mark_type == CD_CIRCLE ||
+ canvas->mark_type == CD_BOX ||
+ canvas->mark_type == CD_DIAMOND))
+ cdCanvasInteriorStyle(canvas, oldinteriorstyle);
+
+ if (canvas->line_style != oldlinestyle &&
+ (canvas->mark_type == CD_STAR ||
+ canvas->mark_type == CD_PLUS ||
+ canvas->mark_type == CD_X ||
+ canvas->mark_type == CD_HOLLOW_BOX ||
+ canvas->mark_type == CD_HOLLOW_CIRCLE ||
+ canvas->mark_type == CD_HOLLOW_DIAMOND))
+ cdCanvasLineStyle(canvas, oldlinestyle);
+
+ if (canvas->line_width != oldlinewidth &&
+ (canvas->mark_type == CD_STAR ||
+ canvas->mark_type == CD_PLUS ||
+ canvas->mark_type == CD_X ||
+ canvas->mark_type == CD_HOLLOW_BOX ||
+ canvas->mark_type == CD_HOLLOW_CIRCLE ||
+ canvas->mark_type == CD_HOLLOW_DIAMOND))
+ cdCanvasLineWidth(canvas, oldlinewidth);
+}
- /* must disable transformation here, because line simulation use cxPixel */
- canvas->use_matrix = 0;
+void cdSimPutImageRectRGBA(cdCanvas* canvas, int iw, int ih, const unsigned char *r, const unsigned char *g, const unsigned char *b, const unsigned char *a, int x, int y, int w, int h, int xmin, int xmax, int ymin, int ymax)
+{
+ int size, i, j, dst, src, *fx, *fy, rw, rh;
+ unsigned char *ar, *ag, *ab, al;
+ (void)ih;
+
+ size = w * h;
+ ar = (unsigned char*)malloc(size*3);
+ if (!ar) return;
+ ag = ar + size;
+ ab = ag + size;
+
+ canvas->cxGetImageRGB(canvas->ctxcanvas, ar, ag, ab, x, y, w, h);
+
+ rw = xmax-xmin+1;
+ rh = ymax-ymin+1;
- simPolyFill(canvas->simulation, poly, n);
+ fx = cdGetZoomTable(w, rw, xmin);
+ fy = cdGetZoomTable(h, rh, ymin);
- canvas->use_matrix = old_use_matrix;
- cdCanvasLineStyle(canvas, oldstyle);
- cdCanvasLineWidth(canvas, oldwidth);
+ for (j = 0; j < h; j++)
+ {
+ for (i = 0; i < w; i++)
+ {
+ dst = j * w + i;
+ src = fy[j] * iw + fx[i];
+ al = a[src];
+ ar[dst] = CD_ALPHA_BLEND(r[src], ar[dst], al);
+ ag[dst] = CD_ALPHA_BLEND(g[src], ag[dst], al);
+ ab[dst] = CD_ALPHA_BLEND(b[src], ab[dst], al);
}
- break;
}
+
+ canvas->cxPutImageRectRGB(canvas->ctxcanvas, w, h, ar, ag, ab, x, y, w, h, 0, 0, 0, 0);
+
+ free(ar);
+
+ free(fx);
+ free(fy);
}
+
+/************************************************************************/
+
+#include "cd_truetype.h"
+#include "sim.h"
+
+void cdSimPolyLine(cdCanvas* canvas, const cdPoint* poly, int n)
+{
+ int i, reset = 1, transform = 0;
+ int old_use_matrix = canvas->use_matrix;
+ int x1, y1, x2, y2;
+
+ if (canvas->use_matrix)
+ transform = 1;
+
+ /* disable line transformation */
+ canvas->use_matrix = 0;
+
+ /* prepare the line style for several lines */
+ if (simLineStyleNoReset)
+ {
+ reset = 0;
+ simLineStyleNoReset = 1;
+ }
+
+ x1 = poly[0].x;
+ y1 = poly[0].y;
+
+ if (transform)
+ cdMatrixTransformPoint(canvas->matrix, x1, y1, &x1, &y1);
+
+ for (i = 0; i < n-1; i++)
+ {
+ x2 = poly[i+1].x;
+ y2 = poly[i+1].y;
+
+ if (transform)
+ cdMatrixTransformPoint(canvas->matrix, x2, y2, &x2, &y2);
+
+ if(canvas->line_width > 1)
+ simLineThick(canvas, x1, y1, x2, y2);
+ else
+ simLineThin(canvas, x1, y1, x2, y2);
+
+ x1 = x2;
+ y1 = y2;
+ }
+
+ if (reset) simLineStyleNoReset = 0;
+ canvas->use_matrix = old_use_matrix;
+}
+
+void cdfSimPolyLine(cdCanvas* canvas, const cdfPoint* poly, int n)
+{
+ int i, reset = 1, transform = 0;
+ int old_use_matrix = canvas->use_matrix;
+ double x1, y1, x2, y2;
+ int last_xi_a = -65535,
+ last_yi_a = -65535,
+ last_xi_b = -65535,
+ last_yi_b = -65535;
+
+ if (canvas->use_matrix)
+ transform = 1;
+
+ /* disable line transformation */
+ canvas->use_matrix = 0;
+
+ /* prepare the line style for several lines */
+ if (simLineStyleNoReset)
+ {
+ reset = 0;
+ simLineStyleNoReset = 1;
+ }
+
+ x1 = poly[0].x;
+ y1 = poly[0].y;
+
+ if (transform)
+ cdfMatrixTransformPoint(canvas->matrix, x1, y1, &x1, &y1);
+
+ for (i = 0; i < n-1; i++)
+ {
+ x2 = poly[i+1].x;
+ y2 = poly[i+1].y;
+
+ if (transform)
+ cdfMatrixTransformPoint(canvas->matrix, x2, y2, &x2, &y2);
+
+ if(canvas->line_width > 1)
+ simfLineThick(canvas, x1, y1, x2, y2);
+ else
+ simfLineThin(canvas, x1, y1, x2, y2, &last_xi_a, &last_yi_a, &last_xi_b, &last_yi_b);
+
+ x1 = x2;
+ y1 = y2;
+ }
+
+ if (reset) simLineStyleNoReset = 0;
+ canvas->use_matrix = old_use_matrix;
+}
+
+static int sCheckIsBox(cdPoint* poly)
+{
+ if (poly[0].x == poly[1].x &&
+ poly[1].y == poly[2].y &&
+ poly[2].x == poly[3].x &&
+ poly[3].y == poly[0].y)
+ return 1;
+
+ if (poly[0].y == poly[1].y &&
+ poly[1].x == poly[2].x &&
+ poly[2].y == poly[3].y &&
+ poly[3].x == poly[0].x)
+ return 1;
+
+ return 0;
+}
+
+void cdSimPolyFill(cdCanvas* canvas, cdPoint* poly, int n)
+{
+ int old_use_matrix = canvas->use_matrix;
+
+ if (canvas->use_matrix)
+ {
+ int i;
+ for(i = 0; i < n; i++) /* can do that because poly is internal of the CD */
+ cdMatrixTransformPoint(canvas->matrix, poly[i].x, poly[i].y, &poly[i].x, &poly[i].y);
+ }
+
+ /* disable fill transformation */
+ canvas->use_matrix = 0;
+
+ if (n == 4 && sCheckIsBox(poly))
+ simFillHorizBox(canvas->simulation, poly[0].x, poly[2].x, poly[0].y, poly[2].x);
+ else
+ simPolyFill(canvas->simulation, poly, n);
+
+ canvas->use_matrix = old_use_matrix;
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-27 07:10:54 +0000