ReactOS 0.4.15-dev-7887-g64a59a1
drawing.c File Reference
#include <win32k.h>
#include <debug.h>
Include dependency graph for drawing.c:

Go to the source code of this file.

Classes

struct  _Rect
 

Macros

#define NDEBUG
 
#define DEGREES_TO_RADIANS(deg)   ((deg)*2*M_PI/360)
 
#define pt(x, y)   app_new_point((x),(y))
 
#define app_fill_rect(dc, r, BrushObj, Pen)    IntFillRect(dc, r.x, r.y, r.width, r.height, BrushObj, Pen)
 

Typedefs

typedef struct _Rect Rect
 
typedef struct _RectPRect
 

Functions

int FASTCALL IntFillRect (DC *dc, INT XLeft, INT YLeft, INT Width, INT Height, PBRUSH pbrush, BOOL Pen)
 
static POINT NTAPI app_new_point (int x, int y)
 
static Rect NTAPI rect (int x, int y, int width, int height)
 
static int NTAPI app_draw_ellipse (DC *g, Rect r, PBRUSH pbrush)
 
static int FASTCALL app_fill_arc_rect (DC *g, Rect r, POINT p0, POINT p1, POINT p2, int start_angle, int end_angle, PBRUSH pbrush, BOOL Pen)
 
static int FASTCALL app_fill_ellipse (DC *g, Rect r, PBRUSH pbrush)
 
static POINT FASTCALL app_boundary_point (Rect r, int angle)
 
int FASTCALL app_fill_arc (DC *g, Rect r, int start_angle, int end_angle, PBRUSH pbrush, BOOL Chord)
 
int app_draw_arc (DC *g, Rect r, int start_angle, int end_angle, PBRUSH pbrushPen, BOOL Chord)
 
BOOL FASTCALL IntFillArc (PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, double StartArc, double EndArc, ARCTYPE arctype)
 
BOOL FASTCALL IntDrawArc (PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, double StartArc, double EndArc, ARCTYPE arctype, PBRUSH pbrush)
 
BOOL FASTCALL IntDrawEllipse (PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, PBRUSH pbrush)
 
BOOL FASTCALL IntFillEllipse (PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, PBRUSH pbrush)
 
BOOL FASTCALL IntFillRoundRect (PDC dc, INT Left, INT Top, INT Right, INT Bottom, INT Wellipse, INT Hellipse, PBRUSH pbrush)
 
BOOL FASTCALL IntDrawRoundRect (PDC dc, INT Left, INT Top, INT Right, INT Bottom, INT Wellipse, INT Hellipse, PBRUSH pbrushPen)
 

Macro Definition Documentation

◆ app_fill_rect

#define app_fill_rect (   dc,
  r,
  BrushObj,
  Pen 
)     IntFillRect(dc, r.x, r.y, r.width, r.height, BrushObj, Pen)

Definition at line 107 of file drawing.c.

◆ DEGREES_TO_RADIANS

#define DEGREES_TO_RADIANS (   deg)    ((deg)*2*M_PI/360)

Definition at line 58 of file drawing.c.

◆ NDEBUG

#define NDEBUG

Definition at line 54 of file drawing.c.

◆ pt

#define pt (   x,
  y 
)    app_new_point((x),(y))

Definition at line 79 of file drawing.c.

Typedef Documentation

◆ PRect

typedef struct _Rect * PRect

◆ Rect

typedef struct _Rect Rect

Function Documentation

◆ app_boundary_point()

static POINT FASTCALL app_boundary_point ( Rect  r,
int  angle 
)
static

Definition at line 741 of file drawing.c.

742{
743 int cx, cy;
744 double tangent;
745
746 cx = r.width;
747 cx /= 2;
748 cx += r.x;
749
750 cy = r.height;
751 cy /= 2;
752 cy += r.y;
753
754 if (angle == 0)
755 return pt(r.x+r.width, cy);
756 else if (angle == 45)
757 return pt(r.x+r.width, r.y);
758 else if (angle == 90)
759 return pt(cx, r.y);
760 else if (angle == 135)
761 return pt(r.x, r.y);
762 else if (angle == 180)
763 return pt(r.x, cy);
764 else if (angle == 225)
765 return pt(r.x, r.y+r.height);
766 else if (angle == 270)
767 return pt(cx, r.y+r.height);
768 else if (angle == 315)
769 return pt(r.x+r.width, r.y+r.height);
770
771 tangent = tan(DEGREES_TO_RADIANS(angle));
772
773 if ((angle > 45) && (angle < 135))
774 return pt((int)(cx+r.height/tangent/2), r.y);
775 else if ((angle > 225) && (angle < 315))
776 return pt((int)(cx-r.height/tangent/2), r.y+r.height);
777 else if ((angle > 135) && (angle < 225))
778 return pt(r.x, (int)(cy+r.width*tangent/2));
779 else
780 return pt(r.x+r.width, (int)(cy-r.width*tangent/2));
781}
_STLP_DECLSPEC complex< float > _STLP_CALL tan(const complex< float > &)
#define pt(x, y)
Definition: drawing.c:79
#define DEGREES_TO_RADIANS(deg)
Definition: drawing.c:58
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLfloat angle
Definition: glext.h:10853
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
_Out_opt_ int * cx
Definition: commctrl.h:585

Referenced by app_draw_arc(), and app_fill_arc().

◆ app_draw_arc()

int app_draw_arc ( DC g,
Rect  r,
int  start_angle,
int  end_angle,
PBRUSH  pbrushPen,
BOOL  Chord 
)

Definition at line 962 of file drawing.c.

963{
964 /* Outer ellipse: e(x,y) = b*b*x*x + a*a*y*y - a*a*b*b */
965
966 int a = r.width / 2;
967 int b = r.height / 2;
968 int x = 0;
969 int y = b;
970 long a2 = a*a;
971 long b2 = b*b;
972 long xcrit = (3 * a2 / 4) + 1;
973 long ycrit = (3 * b2 / 4) + 1;
974 long t = b2 + a2 - 2*a2*b; /* t = e(x+1,y-1) */
975 long dxt = b2*(3+x+x);
976 long dyt = a2*(3-y-y);
977 int d2xt = b2+b2;
978 int d2yt = a2+a2;
979
980 int w = pbrushPen->lWidth;
981
982 /* Inner ellipse: E(X,Y) = B*B*X*X + A*A*Y*Y - A*A*B*B */
983
984 int A = a-w > 0 ? a-w : 0;
985 int B = b-w > 0 ? b-w : 0;
986 int X = 0;
987 int Y = B;
988 long A2 = A*A;
989 long B2 = B*B;
990 long XCRIT = (3 * A2 / 4) + 1;
991 long YCRIT = (3 * B2 / 4) + 1;
992 long T = B2 + A2 - 2*A2*B; /* T = E(X+1,Y-1) */
993 long DXT = B2*(3+X+X);
994 long DYT = A2*(3-Y-Y);
995 int D2XT = B2+B2;
996 int D2YT = A2+A2;
997
998 /* Arc rectangle calculations */
999 int movedown, moveout;
1000 int innerX = 0, prevx, prevy, W;
1001 Rect r1, r2;
1002 int result = 1;
1003
1004 /* Line descriptions */
1005 POINT p0, p1, p2;
1006
1007 /* If angles differ by 360 degrees or more, close the shape */
1008 if ((start_angle + 360 <= end_angle) ||
1009 (start_angle - 360 >= end_angle))
1010 {
1011 return app_draw_ellipse(g, r, pbrushPen);
1012 }
1013
1014 /* Make start_angle >= 0 and <= 360 */
1015 while (start_angle < 0)
1016 start_angle += 360;
1017 start_angle %= 360;
1018
1019 /* Make end_angle >= 0 and <= 360 */
1020 while (end_angle < 0)
1021 end_angle += 360;
1022 end_angle %= 360;
1023
1024 /* Draw nothing if the angles are equal */
1025 if (start_angle == end_angle)
1026 return 1;
1027
1028 /* Find arc wedge line end points */
1029 p1 = app_boundary_point(r, start_angle);
1030 p2 = app_boundary_point(r, end_angle);
1031 if (Chord)
1032 p0 = pt((p1.x+p2.x)/2,(p1.y+p2.y)/2);
1033 else
1034 p0 = pt(r.x + r.width/2, r.y + r.height/2);
1035
1036 /* Determine ellipse rectangles */
1037 r1.x = r.x + a;
1038 r1.y = r.y;
1039 r1.width = r.width & 1; /* i.e. if width is odd */
1040 r1.height = 1;
1041
1042 r2 = r1;
1043 r2.y = r.y + r.height - 1;
1044
1045 prevx = r1.x;
1046 prevy = r1.y;
1047
1048 while (y > 0)
1049 {
1050 while (Y == y)
1051 {
1052 innerX = X;
1053
1054 if (T + A2*Y < XCRIT) /* E(X+1,Y-1/2) <= 0 */
1055 {
1056 /* Move outwards to encounter edge */
1057 X += 1;
1058 T += DXT;
1059 DXT += D2XT;
1060 }
1061 else if (T - B2*X >= YCRIT) /* e(x+1/2,y-1) > 0 */
1062 {
1063 /* Drop down one line */
1064 Y -= 1;
1065 T += DYT;
1066 DYT += D2YT;
1067 }
1068 else
1069 {
1070 /* Drop diagonally down and out */
1071 X += 1;
1072 Y -= 1;
1073 T += DXT + DYT;
1074 DXT += D2XT;
1075 DYT += D2YT;
1076 }
1077 }
1078
1079 movedown = moveout = 0;
1080
1081 W = x - innerX;
1082 if (r1.x + W < prevx)
1083 W = prevx - r1.x;
1084 if (W < w)
1085 W = w;
1086
1087 if (t + a2*y < xcrit) /* e(x+1,y-1/2) <= 0 */
1088 {
1089 /* Move outwards to encounter edge */
1090 x += 1;
1091 t += dxt;
1092 dxt += d2xt;
1093
1094 moveout = 1;
1095 }
1096 else if (t - b2*x >= ycrit) /* e(x+1/2,y-1) > 0 */
1097 {
1098 /* Drop down one line */
1099 y -= 1;
1100 t += dyt;
1101 dyt += d2yt;
1102
1103 movedown = 1;
1104 }
1105 else
1106 {
1107 /* Drop diagonally down and out */
1108 x += 1;
1109 y -= 1;
1110 t += dxt + dyt;
1111 dxt += d2xt;
1112 dyt += d2yt;
1113
1114 movedown = 1;
1115 moveout = 1;
1116 }
1117
1118 if (movedown)
1119 {
1120 if (r1.width == 0)
1121 {
1122 r1.x -= 1;
1123 r1.width += 2;
1124 r2.x -= 1;
1125 r2.width += 2;
1126 moveout = 0;
1127 }
1128
1129 if (r1.x < r.x)
1130 r1.x = r2.x = r.x;
1131 if (r1.width > r.width)
1132 r1.width = r2.width = r.width;
1133 if (r1.y == r2.y-1)
1134 {
1135 r1.x = r2.x = r.x;
1136 r1.width = r2.width = r.width;
1137 }
1138
1139 if ((r1.y < r.y+w) || (r1.x+W >= r1.x+r1.width-W))
1140 {
1142 p0, p1, p2,
1143 start_angle, end_angle, pbrushPen, TRUE);
1145 p0, p1, p2,
1146 start_angle, end_angle, pbrushPen, TRUE);
1147
1148 prevx = r1.x;
1149 prevy = r1.y;
1150 }
1151 else if (r1.y+r1.height < r2.y)
1152 {
1153 /* Draw distinct rectangles */
1155 r1.x,r1.y,W,1),
1156 p0, p1, p2,
1157 start_angle, end_angle, pbrushPen, TRUE);
1159 r1.x+r1.width-W,r1.y,W,1),
1160 p0, p1, p2,
1161 start_angle, end_angle, pbrushPen, TRUE);
1163 r2.x,r2.y,W,1),
1164 p0, p1, p2,
1165 start_angle, end_angle, pbrushPen, TRUE);
1167 r2.x+r2.width-W,r2.y,W,1),
1168 p0, p1, p2,
1169 start_angle, end_angle, pbrushPen, TRUE);
1170
1171 prevx = r1.x;
1172 prevy = r1.y;
1173 }
1174
1175 /* Move down */
1176 r1.y += 1;
1177 r2.y -= 1;
1178 }
1179
1180 if (moveout)
1181 {
1182 /* Move outwards */
1183 r1.x -= 1;
1184 r1.width += 2;
1185 r2.x -= 1;
1186 r2.width += 2;
1187 }
1188 }
1189 if ((x <= a) && (prevy < r2.y))
1190 {
1191 /* Draw final lines */
1192 r1.height = r1.y+r1.height-r2.y;
1193 r1.y = r2.y;
1194
1195 W = w;
1196 if (r.x + W != prevx)
1197 W = prevx - r.x;
1198 if (W < w)
1199 W = w;
1200
1201 if (W+W >= r.width)
1202 {
1203 while (r1.height > 0)
1204 {
1206 r1.y, r.width, 1), p0, p1, p2,
1207 start_angle, end_angle, pbrushPen, TRUE);
1208 r1.y += 1;
1209 r1.height -= 1;
1210 }
1211 return result;
1212 }
1213
1214 while (r1.height > 0)
1215 {
1216 result &= app_fill_arc_rect(g, rect(r.x, r1.y,
1217 W, 1), p0, p1, p2,
1218 start_angle, end_angle, pbrushPen, TRUE);
1219 result &= app_fill_arc_rect(g, rect(r.x+r.width-W,
1220 r1.y, W, 1), p0, p1, p2,
1221 start_angle, end_angle, pbrushPen, TRUE);
1222 r1.y += 1;
1223 r1.height -= 1;
1224 }
1225 }
1226
1227 return result;
1228}
Definition: ehthrow.cxx:93
Definition: ehthrow.cxx:54
#define TRUE
Definition: types.h:120
#define W(I)
#define Y(I)
#define A(row, col)
#define B(row, col)
static int NTAPI app_draw_ellipse(DC *g, Rect r, PBRUSH pbrush)
Definition: drawing.c:124
static int FASTCALL app_fill_arc_rect(DC *g, Rect r, POINT p0, POINT p1, POINT p2, int start_angle, int end_angle, PBRUSH pbrush, BOOL Pen)
Definition: drawing.c:370
static POINT FASTCALL app_boundary_point(Rect r, int angle)
Definition: drawing.c:741
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLdouble GLdouble t
Definition: gl.h:2047
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean g
Definition: glext.h:6204
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
GLuint64EXT * result
Definition: glext.h:11304
#define X(b, s)
#define a
Definition: ke_i.h:78
#define b
Definition: ke_i.h:79
#define T
Definition: mbstring.h:31
static const struct update_accum a2
Definition: msg.c:586
static CRYPT_DATA_BLOB b2[]
Definition: msg.c:582
static DNS_RECORDW r1
Definition: record.c:37
static DNS_RECORDW r2
Definition: record.c:38
& rect
Definition: startmenu.cpp:1413
Definition: polytest.cpp:36
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
BOOL WINAPI Chord(_In_ HDC hdc, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom, _In_ INT xRadial1, _In_ INT yRadial1, _In_ INT xRadial2, _In_ INT yRadial2)
Definition: arc.c:119

Referenced by IntDrawArc(), and IntDrawRoundRect().

◆ app_draw_ellipse()

static int NTAPI app_draw_ellipse ( DC g,
Rect  r,
PBRUSH  pbrush 
)
static

Definition at line 124 of file drawing.c.

125{
126 /* Outer ellipse: e(x,y) = b*b*x*x + a*a*y*y - a*a*b*b */
127
128 int a = r.width / 2;
129 int b = r.height / 2;
130 int x = 0;
131 int y = b;
132 long a2 = a*a;
133 long b2 = b*b;
134 long xcrit = (3 * a2 / 4) + 1;
135 long ycrit = (3 * b2 / 4) + 1;
136 long t = b2 + a2 - 2*a2*b; /* t = e(x+1,y-1) */
137 long dxt = b2*(3+x+x);
138 long dyt = a2*(3-y-y);
139 int d2xt = b2+b2;
140 int d2yt = a2+a2;
141
142 int w = pbrush->lWidth;
143
144 /* Inner ellipse: E(X,Y) = B*B*X*X + A*A*Y*Y - A*A*B*B */
145
146 int A = a-w > 0 ? a-w : 0;
147 int B = b-w > 0 ? b-w : 0;
148 int X = 0;
149 int Y = B;
150 long A2 = A*A;
151 long B2 = B*B;
152 long XCRIT = (3 * A2 / 4) + 1;
153 long YCRIT = (3 * B2 / 4) + 1;
154 long T = B2 + A2 - 2*A2*B; /* T = E(X+1,Y-1) */
155 long DXT = B2*(3+X+X);
156 long DYT = A2*(3-Y-Y);
157 int D2XT = B2+B2;
158 int D2YT = A2+A2;
159
160 int movedown, moveout;
161 int innerX = 0, prevx, prevy, W;
162 Rect r1, r2;
163 int result = 1;
164
165 if ((r.width <= 2) || (r.height <= 2))
166 return app_fill_rect(g, r, pbrush, TRUE);
167
168 r1.x = r.x + a;
169 r1.y = r.y;
170 r1.width = r.width & 1; /* i.e. if width is odd */
171 r1.height = 1;
172
173 r2 = r1;
174 r2.y = r.y + r.height - 1;
175
176 prevx = r1.x;
177 prevy = r1.y;
178
179 while (y > 0)
180 {
181 while (Y == y)
182 {
183 innerX = X;
184
185 if (T + A2*Y < XCRIT) /* E(X+1,Y-1/2) <= 0 */
186 {
187 /* Move outwards to encounter edge */
188 X += 1;
189 T += DXT;
190 DXT += D2XT;
191 }
192 else if (T - B2*X >= YCRIT) /* e(x+1/2,y-1) > 0 */
193 {
194 /* Drop down one line */
195 Y -= 1;
196 T += DYT;
197 DYT += D2YT;
198 }
199 else
200 {
201 /* Drop diagonally down and out */
202 X += 1;
203 Y -= 1;
204 T += DXT + DYT;
205 DXT += D2XT;
206 DYT += D2YT;
207 }
208 }
209
210 movedown = moveout = 0;
211
212 W = x - innerX;
213 if (r1.x + W < prevx)
214 W = prevx - r1.x;
215 if (W < w)
216 W = w;
217
218 if (t + a2*y < xcrit) /* e(x+1,y-1/2) <= 0 */
219 {
220 /* Move outwards to encounter edge */
221 x += 1;
222 t += dxt;
223 dxt += d2xt;
224
225 moveout = 1;
226 }
227 else if (t - b2*x >= ycrit) /* e(x+1/2,y-1) > 0 */
228 {
229 /* Drop down one line */
230 y -= 1;
231 t += dyt;
232 dyt += d2yt;
233
234 movedown = 1;
235 }
236 else
237 {
238 /* Drop diagonally down and out */
239 x += 1;
240 y -= 1;
241 t += dxt + dyt;
242 dxt += d2xt;
243 dyt += d2yt;
244
245 movedown = 1;
246 moveout = 1;
247 }
248
249 if (movedown)
250 {
251 if (r1.width == 0)
252 {
253 r1.x -= 1;
254 r1.width += 2;
255 r2.x -= 1;
256 r2.width += 2;
257 moveout = 0;
258 }
259
260 if (r1.x < r.x)
261 r1.x = r2.x = r.x;
262 if (r1.width > r.width)
263 r1.width = r2.width = r.width;
264 if (r1.y == r2.y-1)
265 {
266 r1.x = r2.x = r.x;
267 r1.width = r2.width = r.width;
268 }
269
270 if ((r1.y < r.y+w) || (r1.x+W >= r1.x+r1.width-W))
271 {
272 result &= app_fill_rect(g, r1, pbrush, TRUE);
273 result &= app_fill_rect(g, r2, pbrush, TRUE);
274
275 prevx = r1.x;
276 prevy = r1.y;
277 }
278 else if (r1.y+r1.height < r2.y)
279 {
280 /* Draw distinct rectangles */
281 result &= app_fill_rect(g, rect(r1.x,r1.y,
282 W,1), pbrush, TRUE);
284 r1.x+r1.width-W,r1.y,W,1), pbrush, TRUE);
286 r2.y,W,1), pbrush, TRUE);
288 r2.x+r2.width-W,r2.y,W,1), pbrush, TRUE);
289
290 prevx = r1.x;
291 prevy = r1.y;
292 }
293
294 /* Move down */
295 r1.y += 1;
296 r2.y -= 1;
297 }
298
299 if (moveout)
300 {
301 /* Move outwards */
302 r1.x -= 1;
303 r1.width += 2;
304 r2.x -= 1;
305 r2.width += 2;
306 }
307 }
308 if ((x <= a) && (prevy < r2.y))
309 {
310 /* Draw final line */
311 r1.height = r1.y+r1.height-r2.y;
312 r1.y = r2.y;
313
314 W = w;
315 if (r.x + W != prevx)
316 W = prevx - r.x;
317 if (W < w)
318 W = w;
319
320 if (W+W >= r.width)
321 {
322 result &= app_fill_rect(g, rect(r.x, r1.y,
323 r.width, r1.height), pbrush, TRUE);
324 return result;
325 }
326
327 result &= app_fill_rect(g, rect(r.x, r1.y, W, r1.height), pbrush, TRUE);
328 result &= app_fill_rect(g, rect(r.x+r.width-W, r1.y,
329 W, r1.height), pbrush, TRUE);
330 }
331 return result;
332}
#define app_fill_rect(dc, r, BrushObj, Pen)
Definition: drawing.c:107

Referenced by app_draw_arc(), IntDrawEllipse(), and IntDrawRoundRect().

◆ app_fill_arc()

int FASTCALL app_fill_arc ( DC g,
Rect  r,
int  start_angle,
int  end_angle,
PBRUSH  pbrush,
BOOL  Chord 
)

Definition at line 785 of file drawing.c.

786{
787 /* e(x,y) = b*b*x*x + a*a*y*y - a*a*b*b */
788
789 int a = r.width / 2;
790 int b = r.height / 2;
791 int x = 0;
792 int y = b;
793 long a2 = a*a;
794 long b2 = b*b;
795 long xcrit = (3 * a2 / 4) + 1;
796 long ycrit = (3 * b2 / 4) + 1;
797 long t = b2 + a2 - 2*a2*b; /* t = e(x+1,y-1) */
798 long dxt = b2*(3+x+x);
799 long dyt = a2*(3-y-y);
800 int d2xt = b2+b2;
801 int d2yt = a2+a2;
802 Rect r1, r2;
803 int movedown, moveout;
804 int result = 1;
805
806 /* Line descriptions */
807 POINT p0, p1, p2;
808
809 /* If angles differ by 360 degrees or more, close the shape */
810 if ((start_angle + 360 <= end_angle) ||
811 (start_angle - 360 >= end_angle))
812 {
813 return app_fill_ellipse(g, r, pbrush);
814 }
815
816 /* Make start_angle >= 0 and <= 360 */
817 while (start_angle < 0)
818 start_angle += 360;
819 start_angle %= 360;
820
821 /* Make end_angle >= 0 and <= 360 */
822 while (end_angle < 0)
823 end_angle += 360;
824 end_angle %= 360;
825
826 /* Draw nothing if the angles are equal */
827 if (start_angle == end_angle)
828 return 1;
829
830 /* Find arc wedge line end points */
831 p1 = app_boundary_point(r, start_angle);
832 p2 = app_boundary_point(r, end_angle);
833 if (Chord)
834 p0 = pt((p1.x+p2.x)/2,(p1.y+p2.y)/2);
835 else
836 p0 = pt(r.x + r.width/2, r.y + r.height/2);
837
838 /* Initialise rectangles to be drawn */
839 r1.x = r.x + a;
840 r1.y = r.y;
841 r1.width = r.width & 1; /* i.e. if width is odd */
842 r1.height = 1;
843
844 r2 = r1;
845 r2.y = r.y + r.height - 1;
846
847 while (y > 0)
848 {
849 moveout = movedown = 0;
850
851 if (t + a2*y < xcrit) /* e(x+1,y-1/2) <= 0 */
852 {
853 /* Move outwards to encounter edge */
854 x += 1;
855 t += dxt;
856 dxt += d2xt;
857
858 moveout = 1;
859 }
860 else if (t - b2*x >= ycrit) /* e(x+1/2,y-1) > 0 */
861 {
862 /* Drop down one line */
863 y -= 1;
864 t += dyt;
865 dyt += d2yt;
866
867 movedown = 1;
868 }
869 else
870 {
871 /* Drop diagonally down and out */
872 x += 1;
873 y -= 1;
874 t += dxt + dyt;
875 dxt += d2xt;
876 dyt += d2yt;
877
878 moveout = 1;
879 movedown = 1;
880 }
881
882 if (movedown)
883 {
884 if (r1.width == 0)
885 {
886 r1.x -= 1;
887 r1.width += 2;
888 r2.x -= 1;
889 r2.width += 2;
890 moveout = 0;
891 }
892
893 if (r1.x < r.x)
894 r1.x = r2.x = r.x;
895 if (r1.width > r.width)
896 r1.width = r2.width = r.width;
897 if (r1.y == r2.y-1)
898 {
899 r1.x = r2.x = r.x;
900 r1.width = r2.width = r.width;
901 }
902
903 if ((r1.width > 0) && (r1.y+r1.height < r2.y))
904 {
905 /* Distinct rectangles */
907 p0, p1, p2,
908 start_angle, end_angle, pbrush, FALSE);
910 p0, p1, p2,
911 start_angle, end_angle, pbrush, FALSE);
912 }
913
914 /* Move down */
915 r1.y += 1;
916 r2.y -= 1;
917 }
918
919 if (moveout)
920 {
921 /* Move outwards */
922 r1.x -= 1;
923 r1.width += 2;
924 r2.x -= 1;
925 r2.width += 2;
926 }
927 }
928 if (r1.y < r2.y)
929 {
930 /* Overlap */
931 r1.x = r.x;
932 r1.width = r.width;
933 r1.height = r2.y+r2.height-r1.y;
934 while (r1.height > 0)
935 {
937 rect(r1.x, r1.y, r1.width, 1),
938 p0, p1, p2, start_angle, end_angle, pbrush, FALSE);
939 r1.y += 1;
940 r1.height -= 1;
941 }
942 }
943 else if (x <= a)
944 {
945 /* Crossover, draw final line */
946 r1.x = r.x;
947 r1.width = r.width;
948 r1.height = r1.y+r1.height-r2.y;
949 r1.y = r2.y;
950 while (r1.height > 0)
951 {
953 rect(r1.x, r1.y, r1.width, 1),
954 p0, p1, p2, start_angle, end_angle, pbrush, FALSE);
955 r1.y += 1;
956 r1.height -= 1;
957 }
958 }
959 return result;
960}
#define FALSE
Definition: types.h:117
static int FASTCALL app_fill_ellipse(DC *g, Rect r, PBRUSH pbrush)
Definition: drawing.c:617

Referenced by IntFillArc(), and IntFillRoundRect().

◆ app_fill_arc_rect()

static int FASTCALL app_fill_arc_rect ( DC g,
Rect  r,
POINT  p0,
POINT  p1,
POINT  p2,
int  start_angle,
int  end_angle,
PBRUSH  pbrush,
BOOL  Pen 
)
static

Definition at line 370 of file drawing.c.

379{
380 int x1, x2;
381 int start_above, end_above;
382 long rise1, run1, rise2, run2;
383
384 rise1 = p1.y - p0.y;
385 run1 = p1.x - p0.x;
386 rise2 = p2.y - p0.y;
387 run2 = p2.x - p0.x;
388
389 if (r.y <= p0.y) //
390 {
391 /* In top half of arc ellipse */
392
393 if (p1.y <= r.y)
394 {
395 /* Start_line is in the top half and is */
396 /* intersected by the current Y scan line */
397 if (rise1 == 0)
398 x1 = p1.x;
399 else
400 x1 = p0.x + (r.y-p0.y)*run1/rise1;
401 start_above = 1;
402 }
403 else if ((start_angle >= 0) && (start_angle <= 180))
404 {
405 /* Start_line is above middle */
406 x1 = p1.x;
407 start_above = 1;
408 }
409 else
410 {
411 /* Start_line is below middle */
412 x1 = r.x + r.width;
413 start_above = 0;
414 }
415 if (x1 < r.x)
416 x1 = r.x;
417 if (x1 > r.x+r.width)
418 x1 = r.x+r.width;
419
420 if (p2.y <= r.y)
421 {
422 /* end_line is in the top half and is */
423 /* intersected by the current Y scan line */
424 if (rise2 == 0)
425 x2 = p2.x;
426 else
427 x2 = p0.x + (r.y-p0.y)*run2/rise2;
428 end_above = 1;
429 }
430 else if ((end_angle >= 0) && (end_angle <= 180))
431 {
432 /* end_line is above middle */
433 x2 = p2.x;
434 end_above = 1;
435 }
436 else
437 {
438 /* end_line is below middle */
439 x2 = r.x;
440 end_above = 0;
441 }
442
443 if (x2 < r.x) x2 = r.x;
444
445 if (x2 > r.x+r.width) x2 = r.x+r.width;
446
447 if (start_above && end_above)
448 {
449 if (start_angle > end_angle)
450 {
451 /* Fill outsides of wedge */
452 if (! app_fill_rect(g, rect(r.x, r.y,
453 x1-r.x, r.height), pbrush, Pen))
454 return 0;
455 return app_fill_rect(g, rect(x2, r.y,
456 r.x+r.width-x2, r.height), pbrush, Pen);
457 }
458 else
459 {
460 /* Fill inside of wedge */
461 r.width = x1-x2;
462 r.x = x2;
463 return app_fill_rect(g, r, pbrush, Pen);
464 }
465 }
466 else if (start_above)
467 {
468 /* Fill to the left of the start_line */
469 r.width = x1-r.x;
470 return app_fill_rect(g, r, pbrush, Pen);
471 }
472 else if (end_above)
473 {
474 /* Fill right of end_line */
475 r.width = r.x+r.width-x2;
476 r.x = x2;
477 return app_fill_rect(g, r, pbrush, Pen);
478 }
479 else
480 {
481 if (start_angle > end_angle)
482 return app_fill_rect(g,r, pbrush, Pen);
483 else
484 return 1;
485 }
486 }
487 else
488 {
489 /* In lower half of arc ellipse */
490
491 if (p1.y >= r.y)
492 {
493 /* start_line is in the lower half and is */
494 /* intersected by the current Y scan line */
495 if (rise1 == 0)
496 x1 = p1.x;
497 else
498 x1 = p0.x + (r.y-p0.y)*run1/rise1;
499 start_above = 0;
500 }
501 else if ((start_angle >= 180) && (start_angle <= 360))
502 {
503 /* start_line is below middle */
504 x1 = p1.x;
505 start_above = 0;
506 }
507 else
508 {
509 /* start_line is above middle */
510 x1 = r.x;
511 start_above = 1;
512 }
513 if (x1 < r.x)
514 x1 = r.x;
515 if (x1 > r.x+r.width)
516 x1 = r.x+r.width;
517
518 if (p2.y >= r.y)
519 {
520 /* end_line is in the lower half and is */
521 /* intersected by the current Y scan line */
522 if (rise2 == 0)
523 x2 = p2.x;
524 else
525 x2 = p0.x + (r.y-p0.y)*run2/rise2;
526 end_above = 0;
527 }
528 else if ((end_angle >= 180) && (end_angle <= 360))
529 {
530 /* end_line is below middle */
531 x2 = p2.x;
532 end_above = 0;
533 }
534 else
535 {
536 /* end_line is above middle */
537 x2 = r.x + r.width;
538 end_above = 1;
539 }
540 if (x2 < r.x)
541 x2 = r.x;
542 if (x2 > r.x+r.width)
543 x2 = r.x+r.width;
544
545 if (start_above && end_above)
546 {
547 if (start_angle > end_angle)
548 return app_fill_rect(g,r, pbrush, Pen);
549 else
550 return 1;
551 }
552 else if (start_above)
553 {
554 /* Fill to the left of end_line */
555 r.width = x2-r.x;
556 return app_fill_rect(g,r, pbrush, Pen);
557 }
558 else if (end_above)
559 {
560 /* Fill right of start_line */
561 r.width = r.x+r.width-x1;
562 r.x = x1;
563 return app_fill_rect(g,r, pbrush, Pen);
564 }
565 else
566 {
567 if (start_angle > end_angle)
568 {
569 /* Fill outsides of wedge */
570 if (! app_fill_rect(g, rect(r.x, r.y,
571 x2-r.x, r.height), pbrush, Pen))
572 return 0;
573 return app_fill_rect(g, rect(x1, r.y,
574 r.x+r.width-x1, r.height), pbrush, Pen);
575 }
576 else
577 {
578 /* Fill inside of wedge */
579 r.width = x2-x1;
580 r.x = x1;
581 return app_fill_rect(g, r, pbrush, Pen);
582 }
583 }
584 }
585}
Definition: gdipluspen.h:23
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3710
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3708

Referenced by app_draw_arc(), and app_fill_arc().

◆ app_fill_ellipse()

static int FASTCALL app_fill_ellipse ( DC g,
Rect  r,
PBRUSH  pbrush 
)
static

Definition at line 617 of file drawing.c.

618{
619 /* e(x,y) = b*b*x*x + a*a*y*y - a*a*b*b */
620
621 int a = r.width / 2;
622 int b = r.height / 2;
623 int x = 0;
624 int y = b;
625 long a2 = a*a;
626 long b2 = b*b;
627 long xcrit = (3 * a2 / 4) + 1;
628 long ycrit = (3 * b2 / 4) + 1;
629 long t = b2 + a2 - 2*a2*b; /* t = e(x+1,y-1) */
630 long dxt = b2*(3+x+x);
631 long dyt = a2*(3-y-y);
632 int d2xt = b2+b2;
633 int d2yt = a2+a2;
634 Rect r1, r2;
635 int result = 1;
636
637 if ((r.width <= 2) || (r.height <= 2))
638 return app_fill_rect(g, r, pbrush, FALSE);
639
640 r1.x = r.x + a;
641 r1.y = r.y;
642 r1.width = r.width & 1; /* i.e. if width is odd */
643 r1.height = 1;
644
645 r2 = r1;
646 r2.y = r.y + r.height - 1;
647
648 while (y > 0)
649 {
650 if (t + a2*y < xcrit) /* e(x+1,y-1/2) <= 0 */
651 {
652 /* Move outwards to encounter edge */
653 x += 1;
654 t += dxt;
655 dxt += d2xt;
656
657 /* Move outwards */
658 r1.x -= 1;
659 r1.width += 2;
660 r2.x -= 1;
661 r2.width += 2;
662 }
663 else if (t - b2*x >= ycrit) /* e(x+1/2,y-1) > 0 */
664 {
665 /* Drop down one line */
666 y -= 1;
667 t += dyt;
668 dyt += d2yt;
669
670 /* Enlarge rectangles */
671 r1.height += 1;
672 r2.height += 1;
673 r2.y -= 1;
674 }
675 else
676 {
677 /* Drop diagonally down and out */
678 x += 1;
679 y -= 1;
680 t += dxt + dyt;
681 dxt += d2xt;
682 dyt += d2yt;
683
684 if ((r1.width > 0) && (r1.height > 0))
685 {
686 /* Draw rectangles first */
687
688 if (r1.y+r1.height < r2.y)
689 {
690 /* Distinct rectangles */
691 result &= app_fill_rect(g, r1, pbrush, FALSE);
692 result &= app_fill_rect(g, r2, pbrush, FALSE);
693 }
694
695 /* Move down */
696 r1.y += r1.height;
697 r1.height = 1;
698 r2.y -= 1;
699 r2.height = 1;
700 }
701 else
702 {
703 /* Skipped pixels on initial diagonal */
704
705 /* Enlarge, rather than moving down */
706 r1.height += 1;
707 r2.height += 1;
708 r2.y -= 1;
709 }
710
711 /* Move outwards */
712 r1.x -= 1;
713 r1.width += 2;
714 r2.x -= 1;
715 r2.width += 2;
716 }
717 }
718 if (r1.y < r2.y)
719 {
720 /* Overlap */
721 r1.x = r.x;
722 r1.width = r.width;
723 r1.height = r2.y+r2.height-r1.y;
724 result &= app_fill_rect(g, r1, pbrush, FALSE);
725 }
726 else if (x <= a)
727 {
728 /* Crossover, draw final line */
729 r1.x = r.x;
730 r1.width = r.width;
731 r1.height = r1.y+r1.height-r2.y;
732 r1.y = r2.y;
733 result &= app_fill_rect(g, r1, pbrush, FALSE);
734 }
735 return result;
736}

Referenced by app_fill_arc(), IntFillEllipse(), and IntFillRoundRect().

◆ app_new_point()

static POINT NTAPI app_new_point ( int  x,
int  y 
)
static

Definition at line 72 of file drawing.c.

73{
74 POINT p;
75 p.x = x;
76 p.y = y;
77 return p;
78}
GLfloat GLfloat p
Definition: glext.h:8902

◆ IntDrawArc()

BOOL FASTCALL IntDrawArc ( PDC  dc,
INT  XLeft,
INT  YLeft,
INT  Width,
INT  Height,
double  StartArc,
double  EndArc,
ARCTYPE  arctype,
PBRUSH  pbrush 
)

Definition at line 1342 of file drawing.c.

1351{
1352 int Start = (int)ceil(StartArc);
1353 int End = (int)ceil(EndArc);
1354 BOOL Chord = (arctype == GdiTypeChord);
1355 // Sort out alignment here.
1356 return app_draw_arc(dc, rect( XLeft, YLeft, Width, Height),
1357 (dc->dclevel.flPath & DCPATH_CLOCKWISE) ? -End : -Start,
1358 (dc->dclevel.flPath & DCPATH_CLOCKWISE) ? -Start : -End,
1359 pbrush, Chord);
1360}
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
int app_draw_arc(DC *g, Rect r, int start_angle, int end_angle, PBRUSH pbrushPen, BOOL Chord)
Definition: drawing.c:962
unsigned int BOOL
Definition: ntddk_ex.h:94
_Check_return_ _CRTIMP double __cdecl ceil(_In_ double x)
static const WCHAR dc[]
@ GdiTypeChord
Definition: ntgdityp.h:22
@ DCPATH_CLOCKWISE
Definition: path.h:8
_In_ HFONT _Out_ PUINT _Out_ PUINT Width
Definition: font.h:89
_In_ HFONT _Out_ PUINT Height
Definition: font.h:88
@ Start
Definition: partlist.h:33

Referenced by IntArc().

◆ IntDrawEllipse()

BOOL FASTCALL IntDrawEllipse ( PDC  dc,
INT  XLeft,
INT  YLeft,
INT  Width,
INT  Height,
PBRUSH  pbrush 
)

Definition at line 1364 of file drawing.c.

1370{
1371 return (BOOL)app_draw_ellipse(dc, rect( XLeft, YLeft, Width, Height), pbrush);
1372}

Referenced by NtGdiEllipse().

◆ IntDrawRoundRect()

BOOL FASTCALL IntDrawRoundRect ( PDC  dc,
INT  Left,
INT  Top,
INT  Right,
INT  Bottom,
INT  Wellipse,
INT  Hellipse,
PBRUSH  pbrushPen 
)

Definition at line 1454 of file drawing.c.

1462{
1463 Rect r;
1464 int rx, ry; /* Radius in x and y directions */
1465 int w = pbrushPen->lWidth;
1466
1467 r = rect( Left, Top, abs(Right-Left), abs(Bottom-Top));
1468 rx = Wellipse/2;
1469 ry = Hellipse/2;
1470
1471 if (Wellipse > r.width)
1472 {
1473 if (Hellipse > r.height) // > W > H
1474 app_draw_ellipse(dc, r, pbrushPen);
1475 else // > W < H
1476 {
1477 app_draw_arc(dc, rect( r.x, r.y, r.width - 1, Hellipse - 1),
1478 0, 180, pbrushPen, FALSE);
1479 app_draw_arc(dc, rect(r.x, Bottom - Hellipse, r.width - 1, Hellipse - 1),
1480 180, 360, pbrushPen, FALSE);
1481 }
1482 }
1483 else if(Hellipse > r.height) // < W > H
1484 {
1485 app_draw_arc(dc, rect(r.x, r.y, Wellipse - 1, r.height - 1),
1486 90, 270, pbrushPen, FALSE);
1487 app_draw_arc(dc, rect(Right - Wellipse, r.y, Wellipse - 1, r.height - 1),
1488 270, 90, pbrushPen, FALSE);
1489 }
1490 else // < W < H
1491 {
1492 app_draw_arc(dc, rect(r.x, r.y, rx+rx, ry+ry),
1493 90, 180, pbrushPen, FALSE);
1494
1495 app_draw_arc(dc, rect(r.x,r.y+r.height-ry-ry,rx+rx,ry+ry),
1496 180, 270, pbrushPen, FALSE);
1497
1498 app_draw_arc(dc, rect(r.x+r.width-rx-rx, r.y+r.height-ry-ry, rx+rx, ry+ry),
1499 270, 360, pbrushPen, FALSE);
1500
1501 app_draw_arc(dc, rect(r.x+r.width-rx-rx,r.y,rx+rx,ry+ry),
1502 0, 90, pbrushPen, FALSE);
1503 }
1504 if ( Hellipse < r.height)
1505 {
1506 app_fill_rect(dc, rect(r.x, r.y+ry+1, w, r.height-ry-ry), pbrushPen, TRUE);
1507
1508
1509 app_fill_rect(dc, rect(r.x+r.width-w, r.y+ry+1, w, r.height-ry-ry),
1510 pbrushPen, TRUE);
1511 }
1512 if ( Wellipse < r.width)
1513 {
1514 app_fill_rect(dc, rect(r.x+rx, r.y+r.height-w, r.width-rx-rx, w),
1515 pbrushPen, TRUE);
1516
1517 app_fill_rect(dc, rect(r.x+rx, r.y, r.width-rx-rx, w), pbrushPen, TRUE);
1518 }
1519 return TRUE;
1520}
static LPHIST_ENTRY Bottom
Definition: history.c:54
static LPHIST_ENTRY Top
Definition: history.c:53
#define abs(i)
Definition: fconv.c:206

Referenced by IntRoundRect().

◆ IntFillArc()

BOOL FASTCALL IntFillArc ( PDC  dc,
INT  XLeft,
INT  YLeft,
INT  Width,
INT  Height,
double  StartArc,
double  EndArc,
ARCTYPE  arctype 
)

Definition at line 1306 of file drawing.c.

1314{
1315 PDC_ATTR pdcattr;
1316 PBRUSH pbrush;
1317 int Start = (int)ceil(StartArc);
1318 int End = (int)ceil(EndArc);
1319 BOOL Chord = (arctype == GdiTypeChord), ret;
1320
1321 pdcattr = dc->pdcattr;
1322
1323 pbrush = BRUSH_ShareLockBrush(pdcattr->hbrush);
1324 if (!pbrush)
1325 {
1326 DPRINT1("FillArc Fail\n");
1328 return FALSE;
1329 }
1330 // Sort out alignment here.
1331 ret = app_fill_arc(dc, rect( XLeft, YLeft, Width, Height),
1332 (dc->dclevel.flPath & DCPATH_CLOCKWISE) ? -End : -Start,
1333 (dc->dclevel.flPath & DCPATH_CLOCKWISE) ? -Start : -End,
1334 pbrush, Chord);
1335
1336 BRUSH_ShareUnlockBrush(pbrush);
1337 return ret;
1338}
#define DPRINT1
Definition: precomp.h:8
int FASTCALL app_fill_arc(DC *g, Rect r, int start_angle, int end_angle, PBRUSH pbrush, BOOL Chord)
Definition: drawing.c:785
#define BRUSH_ShareLockBrush(hBrush)
Definition: brush.h:117
#define BRUSH_ShareUnlockBrush(pBrush)
Definition: brush.h:118
Definition: types.h:101
HANDLE hbrush
Definition: ntgdihdl.h:295
int ret
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22
#define ERROR_INTERNAL_ERROR
Definition: winerror.h:840

Referenced by IntArc().

◆ IntFillEllipse()

BOOL FASTCALL IntFillEllipse ( PDC  dc,
INT  XLeft,
INT  YLeft,
INT  Width,
INT  Height,
PBRUSH  pbrush 
)

Definition at line 1376 of file drawing.c.

1382{
1383 return (BOOL)app_fill_ellipse(dc, rect( XLeft, YLeft, Width, Height), pbrush);
1384}

Referenced by NtGdiEllipse().

◆ IntFillRect()

int FASTCALL IntFillRect ( DC dc,
INT  XLeft,
INT  YLeft,
INT  Width,
INT  Height,
PBRUSH  pbrush,
BOOL  Pen 
)

Definition at line 1234 of file drawing.c.

1241{
1243 RECTL DestRect;
1244 SURFACE *psurf;
1245 POINTL BrushOrigin;
1246 BOOL Ret = TRUE;
1247 PDC_ATTR pdcattr;
1248
1249 ASSERT(pbrush);
1251
1252 psurf = dc->dclevel.pSurface;
1253 if (psurf == NULL)
1254 {
1256 return 0;
1257 }
1258
1259 if (!(pbrush->flAttrs & BR_IS_NULL))
1260 {
1261 pdcattr = dc->pdcattr;
1262
1263 /* Fix negative spaces */
1264 if (Width < 0)
1265 {
1266 XLeft += Width;
1267 Width = 0 - Width;
1268 }
1269 if (Height < 0)
1270 {
1271 YLeft += Height;
1272 Height = 0 - Height;
1273 }
1274
1275 DestRect.left = XLeft;
1276 DestRect.right = XLeft + Width;
1277
1278 DestRect.top = YLeft;
1279 DestRect.bottom = YLeft + Height;
1280
1281 BrushOrigin.x = pbrush->ptOrigin.x;
1282 BrushOrigin.y = pbrush->ptOrigin.y;
1283
1284 if (pdcattr->jROP2 == R2_XORPEN)
1286
1287 Ret = IntEngBitBlt(
1288 &psurf->SurfObj,
1289 NULL,
1290 NULL,
1291 (CLIPOBJ *)&dc->co,
1292 NULL,
1293 &DestRect,
1294 NULL,
1295 NULL,
1296 Pen ? &dc->eboLine.BrushObject : &dc->eboFill.BrushObject,
1297 &BrushOrigin,
1298 ROP);
1299 }
1300
1301 return (int)Ret;
1302}
#define ASSERT_DC_PREPARED(pdc)
Definition: dc.h:300
#define NULL
Definition: types.h:112
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
unsigned long DWORD
Definition: ntddk_ex.h:95
#define BR_IS_NULL
Definition: brush.h:105
#define ROP4_FROM_INDEX(index)
Definition: inteng.h:42
@ R3_OPINDEX_PATINVERT
Definition: inteng.h:28
@ R3_OPINDEX_PATCOPY
Definition: inteng.h:35
#define ASSERT(a)
Definition: mode.c:44
long bottom
Definition: polytest.cpp:53
long right
Definition: polytest.cpp:53
long top
Definition: polytest.cpp:53
long left
Definition: polytest.cpp:53
BYTE jROP2
Definition: ntgdihdl.h:307
LONG y
Definition: windef.h:330
LONG x
Definition: windef.h:329
SURFOBJ SurfObj
Definition: surface.h:8
BOOL APIENTRY IntEngBitBlt(SURFOBJ *psoTrg, SURFOBJ *psoSrc, SURFOBJ *psoMask, CLIPOBJ *pco, XLATEOBJ *pxlo, RECTL *prclTrg, POINTL *pptlSrc, POINTL *pptlMask, BRUSHOBJ *pbo, POINTL *pptlBrush, ROP4 Rop4)
Definition: bitblt.c:656
#define R2_XORPEN
Definition: wingdi.h:353

◆ IntFillRoundRect()

BOOL FASTCALL IntFillRoundRect ( PDC  dc,
INT  Left,
INT  Top,
INT  Right,
INT  Bottom,
INT  Wellipse,
INT  Hellipse,
PBRUSH  pbrush 
)

Definition at line 1388 of file drawing.c.

1396{
1397 Rect r;
1398 int rx, ry; /* Radius in x and y directions */
1399
1400 // x y Width Height
1401 r = rect( Left, Top, abs(Right-Left), abs(Bottom-Top));
1402 rx = Wellipse/2;
1403 ry = Hellipse/2;
1404
1405 if (Wellipse > r.width)
1406 {
1407 if (Hellipse > r.height) // > W > H
1408 app_fill_ellipse(dc, r, pbrush);
1409 else // > W < H
1410 {
1411 app_fill_arc(dc, rect( r.x, r.y, r.width - 1, Hellipse),
1412 0, 180, pbrush,FALSE);
1413 app_fill_arc(dc, rect(r.x, Bottom - Hellipse - 1, r.width - 1, Hellipse),
1414 180, 360, pbrush, FALSE);
1415 }
1416 }
1417 else if(Hellipse > r.height) // < W > H
1418 {
1419 app_fill_arc(dc, rect(r.x, r.y, Wellipse, r.height - 1),
1420 90, 270, pbrush, FALSE);
1421 app_fill_arc(dc, rect(Right - Wellipse - 1, r.y, Wellipse, r.height - 1),
1422 270, 90, pbrush,FALSE);
1423 }
1424 else // < W < H
1425 {
1426 app_fill_arc(dc, rect(r.x, r.y, rx+rx, ry+ry),
1427 90, 180, pbrush, FALSE);
1428
1429 app_fill_arc(dc, rect(r.x, r.y+r.height-ry-ry, rx+rx, ry+ry),
1430 180, 270, pbrush, FALSE);
1431
1432 app_fill_arc(dc, rect(r.x+r.width-rx-rx, r.y+r.height-ry-ry, rx+rx, ry+ry),
1433 270, 360, pbrush,FALSE);
1434
1435 app_fill_arc(dc, rect(r.x+r.width-rx-rx, r.y, rx+rx, ry+ry),
1436 0, 90, pbrush,FALSE);
1437 }
1438 if (Wellipse < r.width)
1439 {
1440 app_fill_rect(dc, rect(r.x+rx, r.y, r.width-rx-rx, ry+1), pbrush, FALSE);
1441 app_fill_rect(dc, rect(r.x+rx, r.y+r.height-ry+1, r.width-rx-rx, ry-1), pbrush, FALSE);
1442 }
1443 if (Hellipse < r.height)
1444 {
1445 app_fill_rect(dc, rect(r.x, r.y+ry+1, r.width, r.height-ry-ry), pbrush, FALSE);
1446 }
1447
1448 return TRUE;
1449}

Referenced by IntRoundRect().

◆ rect()

static Rect NTAPI rect ( int  x,
int  y,
int  width,
int  height 
)
static

Definition at line 84 of file drawing.c.

85{
86 Rect r;
87 r.x = x;
88 r.y = y;
89 r.width = width;
90 r.height = height;
91 return r;
92}
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546