summaryrefslogtreecommitdiff
path: root/src/sim
diff options
context:
space:
mode:
Diffstat (limited to 'src/sim')
-rw-r--r--src/sim/sim.c55
-rw-r--r--src/sim/sim.h6
-rw-r--r--src/sim/sim_linepolyfill.c54
-rw-r--r--src/sim/sim_other.c411
-rw-r--r--src/sim/sim_primitives.c1472
-rw-r--r--src/sim/sim_text.c18
-rw-r--r--src/sim/truetype.h46
7 files changed, 1152 insertions, 910 deletions
diff --git a/src/sim/sim.c b/src/sim/sim.c
index 0c657fa..194265c 100644
--- a/src/sim/sim.c
+++ b/src/sim/sim.c
@@ -89,7 +89,7 @@ void simFillHorizLine(cdSimulation* simulation, int xmin, int y, int xmax)
switch(canvas->interior_style)
{
case CD_SOLID:
- simulation->SolidLine(canvas, xmin,y,xmax);
+ simulation->SolidLine(canvas, xmin,y,xmax, canvas->foreground);
break;
case CD_PATTERN:
simulation->PatternLine(canvas, xmin,xmax,y,canvas->pattern_w,
@@ -107,10 +107,22 @@ void simFillHorizLine(cdSimulation* simulation, int xmin, int y, int xmax)
}
}
-static void simSolidLine(cdCanvas* canvas, int xmin, int y, int xmax)
+void simFillHorizBox(cdSimulation* simulation, int xmin, int xmax, int ymin, int ymax)
{
- /* cdpolySIM and cdboxSIM will set line attributes so this can work */
- canvas->cxLine(canvas->ctxcanvas, xmin, y, xmax, y);
+ cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
+ cdSimulation* simulation = canvas->simulation;
+ int y;
+ for(y=ymin;y<=ymax;y++)
+ simFillHorizLine(simulation, xmin, y, xmax);
+}
+
+static void simSolidLine(cdCanvas* canvas, int xmin, int y, int xmax, long color)
+{
+ int x;
+ for (x = xmin; x <= xmax; x++)
+ {
+ canvas->cxPixel(canvas->ctxcanvas, x,y,color);
+ }
}
static void simPatternLine(cdCanvas* canvas, int xmin, int xmax, int y, int pw, const long *pattern)
@@ -118,12 +130,10 @@ static void simPatternLine(cdCanvas* canvas, int xmin, int xmax, int y, int pw,
cdSimulation* simulation = canvas->simulation;
int x,i;
int xb;
- long curColor, old_color;
+ long curColor;
i = xmin % pw;
-
- old_color = canvas->foreground;
-
+
for (x = xmin; x <= xmax;)
{
if (i == pw)
@@ -143,13 +153,8 @@ static void simPatternLine(cdCanvas* canvas, int xmin, int xmax, int y, int pw,
if(xb==x-1)
canvas->cxPixel(canvas->ctxcanvas, xb,y,curColor);
else
- {
- cdCanvasSetForeground(canvas, curColor);
- simulation->SolidLine(canvas, xb,y,x-1);
- }
+ simulation->SolidLine(canvas, xb,y,x-1, curColor);
}
-
- cdCanvasSetForeground(canvas, old_color);
}
static void simStippleLine(cdCanvas* canvas, int xmin, int xmax, int y, int pw, const unsigned char *stipple)
@@ -166,7 +171,7 @@ static void simStippleLine(cdCanvas* canvas, int xmin, int xmax, int y, int pw,
if(opacity==CD_OPAQUE)
{
bgColor=canvas->background;
- cdCanvasSetForeground(canvas, fgColor);
+
for (x = xmin, i=xmin%pw ; x <= xmax;)
{
if(i==pw)
@@ -185,10 +190,10 @@ static void simStippleLine(cdCanvas* canvas, int xmin, int xmax, int y, int pw,
if(xb==x-1)
canvas->cxPixel(canvas->ctxcanvas, xb,y,fgColor);
else
- simulation->SolidLine(canvas, xb,y,x-1);
+ simulation->SolidLine(canvas, xb,y,x-1,fgColor);
}
}
- cdCanvasSetForeground(canvas, bgColor);
+
for (x = xmin, i=xmin%pw ; x <= xmax;)
{
if(i==pw)
@@ -207,13 +212,12 @@ static void simStippleLine(cdCanvas* canvas, int xmin, int xmax, int y, int pw,
if(xb==x-1)
canvas->cxPixel(canvas->ctxcanvas, xb,y,bgColor);
else
- simulation->SolidLine(canvas, xb,y,x-1);
+ simulation->SolidLine(canvas, xb,y,x-1,bgColor);
}
}
}
else
{
- cdCanvasSetForeground(canvas, fgColor);
for (x = xmin,i=xmin%pw; x <= xmax;)
{
xb=x;
@@ -230,11 +234,10 @@ static void simStippleLine(cdCanvas* canvas, int xmin, int xmax, int y, int pw,
if(xb==x-1)
canvas->cxPixel(canvas->ctxcanvas, xb,y,fgColor);
else
- simulation->SolidLine(canvas, xb,y,x-1);
+ simulation->SolidLine(canvas, xb,y,x-1,fgColor);
}
}
}
- cdCanvasSetForeground(canvas, fgColor);
}
static void simHatchLine(cdCanvas* canvas, int xmin, int xmax, int y, unsigned char hatch)
@@ -269,15 +272,11 @@ static void simHatchLine(cdCanvas* canvas, int xmin, int xmax, int y, unsigned c
if(xb==x)
canvas->cxPixel(canvas->ctxcanvas, xb,y,curColor);
else
- {
- cdCanvasSetForeground(canvas, curColor);
- simulation->SolidLine(canvas, xb,y,x);
- }
+ simulation->SolidLine(canvas, xb,y,x, curColor);
}
}
else
{
- cdCanvasSetForeground(canvas, fgColor);
for (x = xmin; x <= xmax; x++)
{
mask=(hatch&0x80)?1:0;
@@ -296,12 +295,10 @@ static void simHatchLine(cdCanvas* canvas, int xmin, int xmax, int y, unsigned c
if(xb==x)
canvas->cxPixel(canvas->ctxcanvas, xb,y,fgColor);
else
- simulation->SolidLine(canvas, xb,y,x);
+ simulation->SolidLine(canvas, xb,y,x,fgColor);
}
}
}
-
- cdCanvasSetForeground(canvas, fgColor);
}
cdSimulation* cdCreateSimulation(cdCanvas* canvas)
diff --git a/src/sim/sim.h b/src/sim/sim.h
index 8421f53..2a5ac24 100644
--- a/src/sim/sim.h
+++ b/src/sim/sim.h
@@ -20,7 +20,7 @@ struct _cdSimulation
int font_map_n;
/* horizontal line draw functions */
- void (*SolidLine)(cdCanvas* canvas, int xmin, int y, int xmax);
+ void (*SolidLine)(cdCanvas* canvas, int xmin, int y, int xmax, long color);
void (*PatternLine)(cdCanvas* canvas, int xmin, int xmax, int y, int pw, const long *pattern);
void (*StippleLine)(cdCanvas* canvas, int xmin, int xmax, int y, int pw, const unsigned char *stipple);
void (*HatchLine)(cdCanvas* canvas, int xmin, int xmax, int y, unsigned char hatch);
@@ -30,6 +30,7 @@ struct _cdSimulation
void simFillDrawAAPixel(cdCanvas *canvas, int x, int y, unsigned short alpha_weigth);
void simFillHorizLine(cdSimulation* simulation, int xmin, int y, int xmax);
+void simFillHorizBox(cdSimulation* simulation, int xmin, int xmax, int ymin, int ymax);
void simGetPenPos(cdCanvas* canvas, int x, int y, const char* s, int len, FT_Matrix *matrix, FT_Vector *pen);
int simIsPointInPolyWind(cdPoint* poly, int n, int x, int y);
@@ -52,10 +53,9 @@ void simPolyMakeSegments(simLineSegment *segments, int *n_seg, cdPoint* poly, in
void simPolyFill(cdSimulation* simulation, cdPoint* poly, int n);
void simLineThin(cdCanvas* canvas, int x1, int y1, int x2, int y2);
void simLineThick(cdCanvas* canvas, int x1, int y1, int x2, int y2);
+void simfLineThick(cdCanvas* canvas, double x1, double y1, double x2, double y2);
void simfLineThin(cdCanvas* canvas, double x1, double y1, double x2, double y2, int *last_xi_a, int *last_yi_a, int *last_xi_b, int *last_yi_b);
extern int simLineStyleNoReset;
-int simCalcEllipseNumSegments(cdCanvas* canvas, int xc, int yc, int width, int height);
-
#endif
diff --git a/src/sim/sim_linepolyfill.c b/src/sim/sim_linepolyfill.c
index e339fe5..745c70b 100644
--- a/src/sim/sim_linepolyfill.c
+++ b/src/sim/sim_linepolyfill.c
@@ -713,6 +713,60 @@ void simLineThick(cdCanvas* canvas, int x1, int y1, int x2, int y2)
cdCanvasLineStyle(canvas, style);
}
+void simfLineThick(cdCanvas* canvas, double x1, double y1, double x2, double y2)
+{
+ const int interior = canvas->interior_style;
+ const int width = canvas->line_width;
+ const int style = canvas->line_style;
+
+ const double dx = x2-x1;
+ const double dy = y2-y1;
+
+ const double len = hypot(dx,dy);
+
+ const double dnx = dx/len;
+ const double dny = dy/len;
+
+ const double w1 = width/2.0;
+ const double w2 = width-w1;
+
+ const double n1x = w1*dny;
+ const double n1y = -w1*dnx;
+
+ const double n2x = -w2*dny;
+ const double n2y = w2*dnx;
+
+ const double p1x = x1 + n1x;
+ const double p1y = y1 + n1y;
+ const double p2x = x1 + n2x;
+ const double p2y = y1 + n2y;
+ const double p3x = p2x + dx;
+ const double p3y = p2y + dy;
+ const double p4x = p1x + dx;
+ const double p4y = p1y + dy;
+
+ cdPoint poly[4];
+
+ cdCanvasLineWidth(canvas, 1);
+ cdCanvasInteriorStyle(canvas, CD_SOLID);
+ cdCanvasLineStyle(canvas, CD_CONTINUOUS);
+
+ poly[0].x = _cdRound(p1x);
+ poly[0].y = _cdRound(p1y);
+ poly[1].x = _cdRound(p2x);
+ poly[1].y = _cdRound(p2y);
+ poly[2].x = _cdRound(p3x);
+ poly[2].y = _cdRound(p3y);
+ poly[3].x = _cdRound(p4x);
+ poly[3].y = _cdRound(p4y);
+
+ simPolyFill(canvas->simulation, poly, 4);
+
+ cdCanvasLineWidth(canvas, width);
+ cdCanvasInteriorStyle(canvas, interior);
+ cdCanvasLineStyle(canvas, style);
+}
+
void simLineThin(cdCanvas* canvas, int x1, int y1, int x2, int y2)
{
unsigned short ErrorInc, ErrorAcc;
diff --git a/src/sim/sim_other.c b/src/sim/sim_other.c
deleted file mode 100644
index 9079501..0000000
--- a/src/sim/sim_other.c
+++ /dev/null
@@ -1,411 +0,0 @@
-/** \file
- * \brief Simulation that is independent of the Simulation Base Driver
- *
- * See Copyright Notice in cd.h
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <math.h>
-#include <memory.h>
-
-#include "cd.h"
-#include "cd_private.h"
-
-
-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_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_HOLLOW_DIAMOND:
- canvas->cxLine(canvas->ctxcanvas, left, y, x, top);
- canvas->cxLine(canvas->ctxcanvas, x, top, right, y);
- canvas->cxLine(canvas->ctxcanvas, right, y, x, bottom);
- canvas->cxLine(canvas->ctxcanvas, x, bottom, left, y);
- break;
- case CD_X:
- canvas->cxLine(canvas->ctxcanvas, left, bottom, right, top);
- canvas->cxLine(canvas->ctxcanvas, left, top, right, bottom);
- 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_DIAMOND:
- {
- cdPoint poly[5];
- 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;
- canvas->cxPoly(canvas->ctxcanvas, CD_FILL, poly, 4);
- }
- break;
- }
-
- 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);
-}
-
-/* Setup Bezier coefficient array once for each control polygon.
- */
-static void BezierForm(const cdPoint* p, cdfPoint* c)
-{
- int k;
- static int choose[4] = {1, 3, 3, 1};
- for (k = 0; k < 4; k++)
- {
- c[k].x = p[k].x * choose[k];
- c[k].y = p[k].y * choose[k];
- }
-}
-
-static void fBezierForm(const cdfPoint* p, cdfPoint* c)
-{
- int k;
- static int choose[4] = {1, 3, 3, 1};
- for (k = 0; k < 4; k++)
- {
- c[k].x = p[k].x * choose[k];
- c[k].y = p[k].y * choose[k];
- }
-}
-
-/* Return Point pt(t), t <= 0 <= 1 from C.
- * BezierForm must be called once for any given control polygon.
- */
-static void BezierCurve(const cdfPoint* c, cdfPoint *pt, double t)
-{
- int k;
- double t1, tt, u;
- cdfPoint b[4];
-
- u = t;
-
- b[0].x = c[0].x;
- b[0].y = c[0].y;
- for(k = 1; k < 4; k++)
- {
- b[k].x = c[k].x * u;
- b[k].y = c[k].y * u;
- u =u*t;
- }
-
- 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;
- }
-}
-
-static int BezierNumSegments(cdCanvas* canvas, const cdPoint* p)
-{
- int i, K, dx, dy, d,
- xmax = p[0].x,
- ymax = p[0].y,
- xmin = p[0].x,
- ymin = p[0].y;
-
- 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;
- }
-
- if (canvas->use_matrix)
- {
- cdMatrixTransformPoint(canvas->matrix, xmin, ymin, &xmin, &ymin);
- cdMatrixTransformPoint(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 int fBezierNumSegments(cdCanvas* canvas, const cdfPoint* p)
-{
- int i, K, d;
- double dx, dy,
- xmax = p[0].x,
- ymax = p[0].y,
- xmin = p[0].x,
- ymin = p[0].y;
-
- 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;
- }
-
- /* 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;
-}
-
-/* from sim.h */
-void simfLineThin(cdCanvas* canvas, double x1, double y1, double x2, double y2, int *last_xi_a, int *last_yi_a, int *last_xi_b, int *last_yi_b);
-
-/* Quick and Simple Bezier Curve Drawing --- Robert D. Miller
- * Graphics GEMS V */
-void cdSimPolyBezier(cdCanvas* canvas, const cdPoint* points, int n)
-{
- int i = 0, k, K, poly_max = 0;
- cdfPoint pt, prev_pt;
- cdfPoint bezier_control[4];
- cdPoint* poly = NULL;
- int use_poly = 0,
- last_xi_a = -65535,
- last_yi_a = -65535,
- last_xi_b = -65535,
- last_yi_b = -65535;
-
- /* Use special floating point anti-alias line draw when
- line_width==1, and using cdlineSIM. */
- if (canvas->line_width > 1 || canvas->cxLine != cdlineSIM)
- use_poly = 1;
-
- n--; /* first n is 4 */
- while (n >= 3)
- {
- BezierForm(points+i, bezier_control);
- K = BezierNumSegments(canvas, points+i);
-
- if (use_poly && poly_max < K+1)
- {
- poly = realloc(poly, sizeof(cdPoint)*(K+1)); /* K+1 points */
- if (!poly) return;
- poly_max = K+1;
- }
-
- /* first segment */
- BezierCurve(bezier_control, &pt, 0);
- if (use_poly)
- {
- poly[0].x = _cdRound(pt.x);
- poly[0].y = _cdRound(pt.y);
- }
- else
- prev_pt = pt;
-
- for(k = 1; k < K+1; k++)
- {
- BezierCurve(bezier_control, &pt, (double)k/(double)K);
-
- if (use_poly)
- {
- poly[k].x = _cdRound(pt.x);
- poly[k].y = _cdRound(pt.y);
- }
- else
- {
- int old_use_matrix = canvas->use_matrix;
- double x1 = prev_pt.x,
- y1 = prev_pt.y,
- x2 = pt.x,
- y2 = pt.y;
-
- 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;
-
- simfLineThin(canvas, x1, y1, x2, y2, &last_xi_a, &last_yi_a, &last_xi_b, &last_yi_b);
-
- canvas->use_matrix = old_use_matrix;
- prev_pt = pt;
- }
- }
-
- if (use_poly)
- canvas->cxPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, k);
-
- n -= 3; i += 3;
- }
-
- if (poly) free(poly);
-}
-
-void cdfSimPolyBezier(cdCanvas* canvas, const cdfPoint* points, int n)
-{
- int i = 0, k, K, poly_max = 0;
- cdfPoint pt;
- cdfPoint bezier_control[4];
- cdfPoint* poly = NULL;
-
- n--; /* first n is 4 */
- while (n >= 3)
- {
- fBezierForm(points+i, bezier_control);
- K = fBezierNumSegments(canvas, points+i);
-
- if (poly_max < K+1)
- {
- poly = realloc(poly, sizeof(cdfPoint)*(K+1)); /* K+1 points */
- if (!poly) return;
- poly_max = K+1;
- }
-
- /* first segment */
- BezierCurve(bezier_control, &pt, 0);
- poly[0].x = _cdRound(pt.x);
- poly[0].y = _cdRound(pt.y);
-
- for(k = 1; k < K+1; k++)
- {
- BezierCurve(bezier_control, &pt, (double)k/(double)K);
-
- poly[k].x = _cdRound(pt.x);
- poly[k].y = _cdRound(pt.y);
- }
-
- canvas->cxFPoly(canvas->ctxcanvas, CD_OPEN_LINES, poly, k);
- n -= 3; i += 3;
- }
-
- if (poly) free(poly);
-}
-
-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;
-
- 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;
-
- fx = cdGetZoomTable(w, rw, xmin);
- fy = cdGetZoomTable(h, rh, ymin);
-
- 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);
- }
- }
-
- canvas->cxPutImageRectRGB(canvas->ctxcanvas, w, h, ar, ag, ab, x, y, w, h, 0, 0, 0, 0);
-
- free(ar);
-
- free(fx);
- free(fy);
-}
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;
+}
+
diff --git a/src/sim/sim_text.c b/src/sim/sim_text.c
index b8df98f..cf171fd 100644
--- a/src/sim/sim_text.c
+++ b/src/sim/sim_text.c
@@ -106,7 +106,7 @@ static const char* find_font_filename(cdSimulation* simulation, const char* name
return NULL;
}
-int cdfontSIM(cdCtxCanvas* ctxcanvas, const char *type_face, int style, int size)
+int cdSimFontFT(cdCtxCanvas* ctxcanvas, const char *type_face, int style, int size)
{
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
@@ -145,7 +145,7 @@ int cdfontSIM(cdCtxCanvas* ctxcanvas, const char *type_face, int style, int size
}
}
-void cdgetfontdimSIM(cdCtxCanvas* ctxcanvas, int *max_width, int *height, int *ascent, int *descent)
+void cdSimGetFontDimFT(cdCtxCanvas* ctxcanvas, int *max_width, int *height, int *ascent, int *descent)
{
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
cdSimulation* simulation = canvas->simulation;
@@ -159,7 +159,7 @@ void cdgetfontdimSIM(cdCtxCanvas* ctxcanvas, int *max_width, int *height, int *a
if(height) *height= simulation->tt_text->max_height;
}
-void cdgettextsizeSIM(cdCtxCanvas* ctxcanvas, const char *s, int len, int *width, int *height)
+void cdSimGetTextSizeFT(cdCtxCanvas* ctxcanvas, const char *s, int len, int *width, int *height)
{
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
cdSimulation* simulation = canvas->simulation;
@@ -199,7 +199,7 @@ static void simDrawTextBitmap(cdSimulation* simulation, FT_Bitmap* bitmap, int x
int height = bitmap->rows;
int size = width*height;
int rgba_data_size = size*4;
- int olduse_matrix = simulation->canvas->use_matrix;
+ int old_use_matrix = simulation->canvas->use_matrix;
/* avoid spaces */
if (width == 0 || height == 0)
@@ -331,7 +331,7 @@ static void simDrawTextBitmap(cdSimulation* simulation, FT_Bitmap* bitmap, int x
simulation->canvas->cxPutImageRectRGBA(simulation->canvas->ctxcanvas, width,height,red,green,blue,alpha,x,y,width,height,0,width-1,0,height-1);
}
- simulation->canvas->use_matrix = olduse_matrix;
+ simulation->canvas->use_matrix = old_use_matrix;
}
void simGetPenPos(cdCanvas* canvas, int x, int y, const char* s, int len, FT_Matrix *matrix, FT_Vector *pen)
@@ -340,8 +340,8 @@ void simGetPenPos(cdCanvas* canvas, int x, int y, const char* s, int len, FT_Mat
int old_invert_yaxis = canvas->invert_yaxis;
int w, h, ascent, height, baseline;
- cdgettextsizeSIM(canvas->ctxcanvas, s, len, &w, &h);
- cdgetfontdimSIM(canvas->ctxcanvas, NULL, &height, &ascent, NULL);
+ cdSimGetTextSizeFT(canvas->ctxcanvas, s, len, &w, &h);
+ cdSimGetFontDimFT(canvas->ctxcanvas, NULL, &height, &ascent, NULL);
baseline = height - ascent;
/* in this case we are always upwards */
@@ -379,7 +379,7 @@ void simGetPenPos(cdCanvas* canvas, int x, int y, const char* s, int len, FT_Mat
FT_Matrix_Multiply(&text_matrix, matrix);
}
- if (canvas->use_matrix && !canvas->invert_yaxis)
+ if (canvas->use_matrix)
{
FT_Matrix trans_matrix;
trans_matrix.xx = (FT_Fixed)(canvas->matrix[0]*0x10000L);
@@ -399,7 +399,7 @@ void simGetPenPos(cdCanvas* canvas, int x, int y, const char* s, int len, FT_Mat
}
-void cdtextSIM(cdCtxCanvas* ctxcanvas, int x, int y, const char* s, int len)
+void cdSimTextFT(cdCtxCanvas* ctxcanvas, int x, int y, const char* s, int len)
{
cdCanvas* canvas = ((cdCtxCanvasBase*)ctxcanvas)->canvas;
cdSimulation* simulation = canvas->simulation;
diff --git a/src/sim/truetype.h b/src/sim/truetype.h
deleted file mode 100644
index 5675998..0000000
--- a/src/sim/truetype.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/** \file
- * \brief Text and Font Simulation using FreeType library.
- *
- * See Copyright Notice in cd.h
- */
-
-#ifndef __TRUETYPE_H
-#define __TRUETYPE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "ft2build.h"
-#include FT_FREETYPE_H
-
-/*
- In CD version 4.4 we start to use FreeType 2.
- Only TrueType font support is enabled.
-*/
-
-typedef struct _cdTT_Text
-{
- FT_Library library;
- FT_Face face;
-
- unsigned char* rgba_data;
- int rgba_data_size;
-
- int max_height;
- int max_width;
- int descent;
- int ascent;
-
-}cdTT_Text;
-
-cdTT_Text* cdTT_create(void);
-void cdTT_free(cdTT_Text * tt_text);
-int cdTT_load(cdTT_Text * tt_text, const char *font,int size, double xres, double yres);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* ifndef _CD_TRUETYPE_ */
-
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-26 06:37:43 +0000