1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
|
// 7 september 2015
#include "uipriv_windows.hpp"
#include "draw.hpp"
// TODO
// - write a test for transform followed by clip and clip followed by transform to make sure they work the same as on gtk+ and cocoa
// - write a test for nested transforms for gtk+
struct uiDrawPath {
ID2D1PathGeometry *path;
ID2D1GeometrySink *sink;
BOOL inFigure;
};
uiDrawPath *uiDrawNewPath(uiDrawFillMode fillmode)
{
uiDrawPath *p;
HRESULT hr;
p = uiNew(uiDrawPath);
hr = d2dfactory->CreatePathGeometry(&(p->path));
if (hr != S_OK)
logHRESULT(L"error creating path", hr);
hr = p->path->Open(&(p->sink));
if (hr != S_OK)
logHRESULT(L"error opening path", hr);
switch (fillmode) {
case uiDrawFillModeWinding:
p->sink->SetFillMode(D2D1_FILL_MODE_WINDING);
break;
case uiDrawFillModeAlternate:
p->sink->SetFillMode(D2D1_FILL_MODE_ALTERNATE);
break;
}
return p;
}
void uiDrawFreePath(uiDrawPath *p)
{
if (p->inFigure)
p->sink->EndFigure(D2D1_FIGURE_END_OPEN);
if (p->sink != NULL)
// TODO close sink first?
p->sink->Release();
p->path->Release();
uiFree(p);
}
void uiDrawPathNewFigure(uiDrawPath *p, double x, double y)
{
D2D1_POINT_2F pt;
if (p->inFigure)
p->sink->EndFigure(D2D1_FIGURE_END_OPEN);
pt.x = x;
pt.y = y;
p->sink->BeginFigure(pt, D2D1_FIGURE_BEGIN_FILLED);
p->inFigure = TRUE;
}
// Direct2D arcs require a little explanation.
// An arc in Direct2D is defined by the chord between the endpoints.
// There are four possible arcs with the same two endpoints that you can draw this way.
// See https://www.youtube.com/watch?v=ATS0ANW1UxQ for a demonstration.
// There is a property rotationAngle which deals with the rotation /of the entire ellipse that forms an ellpitical arc/ - it's effectively a transformation on the arc.
// That is to say, it's NOT THE SWEEP.
// The sweep is defined by the start and end points and whether the arc is "large".
// As a result, this design does not allow for full circles or ellipses with a single arc; they have to be simulated with two.
struct arc {
double xCenter;
double yCenter;
double radius;
double startAngle;
double sweep;
int negative;
};
// this is used for the comparison below
// if it falls apart it can be changed later
#define aerMax 6 * DBL_EPSILON
static void drawArc(uiDrawPath *p, struct arc *a, void (*startFunction)(uiDrawPath *, double, double))
{
double sinx, cosx;
double startX, startY;
double endX, endY;
D2D1_ARC_SEGMENT as;
BOOL fullCircle;
double absSweep;
// as above, we can't do a full circle with one arc
// simulate it with two half-circles
// of course, we have a dragon: equality on floating-point values!
// I've chosen to do the AlmostEqualRelative() technique in https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
fullCircle = FALSE;
// use the absolute value to tackle both ≥2π and ≤-2π at the same time
absSweep = fabs(a->sweep);
if (absSweep > (2 * uiPi)) // this part is easy
fullCircle = TRUE;
else {
double aerDiff;
aerDiff = fabs(absSweep - (2 * uiPi));
// if we got here then we know a->sweep is larger (or the same!)
fullCircle = aerDiff <= absSweep * aerMax;
}
// TODO make sure this works right for the negative direction
if (fullCircle) {
a->sweep = uiPi;
drawArc(p, a, startFunction);
a->startAngle += uiPi;
drawArc(p, a, NULL);
return;
}
// first, figure out the arc's endpoints
// unfortunately D2D1SinCos() is only defined on Windows 8 and newer
// the MSDN page doesn't say this, but says it requires d2d1_1.h, which is listed as only supported on Windows 8 and newer elsewhere on MSDN
// so we must use sin() and cos() and hope it's right...
sinx = sin(a->startAngle);
cosx = cos(a->startAngle);
startX = a->xCenter + a->radius * cosx;
startY = a->yCenter + a->radius * sinx;
sinx = sin(a->startAngle + a->sweep);
cosx = cos(a->startAngle + a->sweep);
endX = a->xCenter + a->radius * cosx;
endY = a->yCenter + a->radius * sinx;
// now do the initial step to get the current point to be the start point
// this is either creating a new figure, drawing a line, or (in the case of our full circle code above) doing nothing
if (startFunction != NULL)
(*startFunction)(p, startX, startY);
// now we can draw the arc
as.point.x = endX;
as.point.y = endY;
as.size.width = a->radius;
as.size.height = a->radius;
as.rotationAngle = 0; // as above, not relevant for circles
if (a->negative)
as.sweepDirection = D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE;
else
as.sweepDirection = D2D1_SWEEP_DIRECTION_CLOCKWISE;
// TODO explain the outer if
if (!a->negative)
if (a->sweep > uiPi)
as.arcSize = D2D1_ARC_SIZE_LARGE;
else
as.arcSize = D2D1_ARC_SIZE_SMALL;
else
// TODO especially this part
if (a->sweep > uiPi)
as.arcSize = D2D1_ARC_SIZE_SMALL;
else
as.arcSize = D2D1_ARC_SIZE_LARGE;
p->sink->AddArc(&as);
}
void uiDrawPathNewFigureWithArc(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative)
{
struct arc a;
a.xCenter = xCenter;
a.yCenter = yCenter;
a.radius = radius;
a.startAngle = startAngle;
a.sweep = sweep;
a.negative = negative;
drawArc(p, &a, uiDrawPathNewFigure);
}
void uiDrawPathLineTo(uiDrawPath *p, double x, double y)
{
D2D1_POINT_2F pt;
pt.x = x;
pt.y = y;
p->sink->AddLine(pt);
}
void uiDrawPathArcTo(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative)
{
struct arc a;
a.xCenter = xCenter;
a.yCenter = yCenter;
a.radius = radius;
a.startAngle = startAngle;
a.sweep = sweep;
a.negative = negative;
drawArc(p, &a, uiDrawPathLineTo);
}
void uiDrawPathBezierTo(uiDrawPath *p, double c1x, double c1y, double c2x, double c2y, double endX, double endY)
{
D2D1_BEZIER_SEGMENT s;
s.point1.x = c1x;
s.point1.y = c1y;
s.point2.x = c2x;
s.point2.y = c2y;
s.point3.x = endX;
s.point3.y = endY;
p->sink->AddBezier(&s);
}
void uiDrawPathCloseFigure(uiDrawPath *p)
{
p->sink->EndFigure(D2D1_FIGURE_END_CLOSED);
p->inFigure = FALSE;
}
void uiDrawPathAddRectangle(uiDrawPath *p, double x, double y, double width, double height)
{
// this is the same algorithm used by cairo and Core Graphics, according to their documentations
uiDrawPathNewFigure(p, x, y);
uiDrawPathLineTo(p, x + width, y);
uiDrawPathLineTo(p, x + width, y + height);
uiDrawPathLineTo(p, x, y + height);
uiDrawPathCloseFigure(p);
}
void uiDrawPathEnd(uiDrawPath *p)
{
HRESULT hr;
if (p->inFigure) {
p->sink->EndFigure(D2D1_FIGURE_END_OPEN);
// needed for uiDrawFreePath()
p->inFigure = FALSE;
}
hr = p->sink->Close();
if (hr != S_OK)
logHRESULT(L"error closing path", hr);
p->sink->Release();
// also needed for uiDrawFreePath()
p->sink = NULL;
}
ID2D1PathGeometry *pathGeometry(uiDrawPath *p)
{
if (p->sink != NULL)
userbug("You cannot draw with a uiDrawPath that was not ended. (path: %p)", p);
return p->path;
}
|