ReactOS 0.4.15-dev-8235-gcd88a97
gdiplusbrush.h
Go to the documentation of this file.
1/*
2 * GdiPlusBrush.h
3 *
4 * Windows GDI+
5 *
6 * This file is part of the w32api package.
7 *
8 * THIS SOFTWARE IS NOT COPYRIGHTED
9 *
10 * This source code is offered for use in the public domain. You may
11 * use, modify or distribute it freely.
12 *
13 * This code is distributed in the hope that it will be useful but
14 * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
15 * DISCLAIMED. This includes but is not limited to warranties of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
17 */
18
19#ifndef _GDIPLUSBRUSH_H
20#define _GDIPLUSBRUSH_H
21
22class Brush : public GdiplusBase
23{
24 public:
25 friend class Graphics;
26 friend class Pen;
27
28 virtual ~Brush()
29 {
30 DllExports::GdipDeleteBrush(nativeBrush);
31 }
32
33 Brush *
34 Clone() const
35 {
36 GpBrush *brush = NULL;
37 SetStatus(DllExports::GdipCloneBrush(nativeBrush, &brush));
38 if (lastStatus != Ok)
39 return NULL;
40
41 Brush *newBrush = new Brush(brush, lastStatus);
42 if (newBrush == NULL)
43 {
44 DllExports::GdipDeleteBrush(brush);
45 }
46 return newBrush;
47 }
48
49 Status
51 {
52 return lastStatus;
53 }
54
56 GetType() const
57 {
59 SetStatus(DllExports::GdipGetBrushType(nativeBrush, &type));
60 return type;
61 }
62
63 protected:
66
68 {
69 }
70
72 {
73 }
74
75 Status
77 {
78 if (status != Ok)
80 return status;
81 }
82
83 void
85 {
86 nativeBrush = brush;
87 }
88
89 private:
90 // Brush is not copyable
91 Brush(const Brush &);
92 Brush &
93 operator=(const Brush &);
94
95 // get native
96 friend inline GpBrush *&
97 getNat(const Brush *brush)
98 {
99 return const_cast<Brush *>(brush)->nativeBrush;
100 }
101};
102
103class HatchBrush : public Brush
104{
105 public:
106 friend class Pen;
107
108 HatchBrush(HatchStyle hatchStyle, const Color &foreColor, const Color &backColor)
109 {
110 GpHatch *brush = NULL;
111 lastStatus = DllExports::GdipCreateHatchBrush(hatchStyle, foreColor.GetValue(), backColor.GetValue(), &brush);
112 SetNativeBrush(brush);
113 }
114
115 Status
117 {
118 if (!color)
120
121 ARGB argb;
122 GpHatch *hatch = GetNativeHatch();
123 SetStatus(DllExports::GdipGetHatchBackgroundColor(hatch, &argb));
124
125 color->SetValue(argb);
126 return lastStatus;
127 }
128
129 Status
131 {
132 if (!color)
134
135 ARGB argb;
136 GpHatch *hatch = GetNativeHatch();
137 SetStatus(DllExports::GdipGetHatchForegroundColor(hatch, &argb));
138
139 color->SetValue(argb);
140 return lastStatus;
141 }
142
145 {
146 HatchStyle hatchStyle;
147 GpHatch *hatch = GetNativeHatch();
148 SetStatus(DllExports::GdipGetHatchStyle(hatch, &hatchStyle));
149 return hatchStyle;
150 }
151
152 protected:
154 {
155 }
156
157 GpHatch *
159 {
160 return static_cast<GpHatch *>(nativeBrush);
161 }
162};
163
165{
166 public:
167 friend class Pen;
168
169 LinearGradientBrush(const PointF &point1, const PointF &point2, const Color &color1, const Color &color2)
170 {
171 GpLineGradient *brush = NULL;
172 lastStatus = DllExports::GdipCreateLineBrush(
173 &point1, &point2, color1.GetValue(), color2.GetValue(), WrapModeTile, &brush);
174 SetNativeBrush(brush);
175 }
176
178 const Rect &rect,
179 const Color &color1,
180 const Color &color2,
181 REAL angle,
182 BOOL isAngleScalable = FALSE)
183 {
184 GpLineGradient *brush = NULL;
185 lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngleI(
186 &rect, color1.GetValue(), color2.GetValue(), angle, isAngleScalable, WrapModeTile, &brush);
187 SetNativeBrush(brush);
188 }
189
190 LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
191 {
192 GpLineGradient *brush = NULL;
193 lastStatus = DllExports::GdipCreateLineBrushFromRectI(
194 &rect, color1.GetValue(), color2.GetValue(), mode, WrapModeTile, &brush);
195 SetNativeBrush(brush);
196 }
197
198 LinearGradientBrush(const Point &point1, const Point &point2, const Color &color1, const Color &color2)
199 {
200 GpLineGradient *brush = NULL;
201 lastStatus = DllExports::GdipCreateLineBrushI(
202 &point1, &point2, color1.GetValue(), color2.GetValue(), WrapModeTile, &brush);
203 SetNativeBrush(brush);
204 }
205
207 const RectF &rect,
208 const Color &color1,
209 const Color &color2,
210 REAL angle,
211 BOOL isAngleScalable = FALSE)
212 {
213 GpLineGradient *brush = NULL;
214 lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngle(
215 &rect, color1.GetValue(), color2.GetValue(), angle, isAngleScalable, WrapModeTile, &brush);
216 SetNativeBrush(brush);
217 }
218
219 LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
220 {
221 GpLineGradient *brush = NULL;
222 lastStatus = DllExports::GdipCreateLineBrushFromRect(
223 &rect, color1.GetValue(), color2.GetValue(), mode, WrapModeTile, &brush);
224 SetNativeBrush(brush);
225 }
226
227 Status
228 GetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
229 {
230 GpLineGradient *gradient = GetNativeGradient();
231 return SetStatus(DllExports::GdipGetLineBlend(gradient, blendFactors, blendPositions, count));
232 }
233
234 INT
236 {
237 INT count = 0;
238 GpLineGradient *gradient = GetNativeGradient();
239 SetStatus(DllExports::GdipGetLineBlendCount(gradient, &count));
240 return count;
241 }
242
243 BOOL
245 {
246 BOOL useGammaCorrection;
247 GpLineGradient *gradient = GetNativeGradient();
248 SetStatus(DllExports::GdipGetLineGammaCorrection(gradient, &useGammaCorrection));
249 return useGammaCorrection;
250 }
251
252 INT
254 {
255 INT count = 0;
256 GpLineGradient *gradient = GetNativeGradient();
257 SetStatus(DllExports::GdipGetLinePresetBlendCount(gradient, &count));
258 return count;
259 }
260
261 Status
262 GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count) const
263 {
265 }
266
267 Status
268 GetLinearColors(Color *colors) const
269 {
270 if (!colors)
272
273 GpLineGradient *gradient = GetNativeGradient();
274
275 ARGB argb[2];
276 SetStatus(DllExports::GdipGetLineColors(gradient, argb));
277 if (lastStatus == Ok)
278 {
279 colors[0] = Color(argb[0]);
280 colors[1] = Color(argb[1]);
281 }
282 return lastStatus;
283 }
284
285 Status
287 {
288 GpLineGradient *gradient = GetNativeGradient();
289 return SetStatus(DllExports::GdipGetLineRectI(gradient, rect));
290 }
291
292 Status
294 {
295 GpLineGradient *gradient = GetNativeGradient();
296 return SetStatus(DllExports::GdipGetLineRect(gradient, rect));
297 }
298
299 Status
301 {
302 GpLineGradient *gradient = GetNativeGradient();
303 return SetStatus(DllExports::GdipGetLineTransform(gradient, getNat(matrix)));
304 }
305
308 {
309
310 WrapMode wrapMode;
311 GpLineGradient *gradient = GetNativeGradient();
312 SetStatus(DllExports::GdipGetLineWrapMode(gradient, &wrapMode));
313 return wrapMode;
314 }
315
316 Status
318 {
319 GpLineGradient *gradient = GetNativeGradient();
320 return SetStatus(DllExports::GdipMultiplyLineTransform(gradient, getNat(matrix), order));
321 }
322
323 Status
325 {
326 GpLineGradient *gradient = GetNativeGradient();
327 return SetStatus(DllExports::GdipResetLineTransform(gradient));
328 }
329
330 Status
332 {
333 GpLineGradient *gradient = GetNativeGradient();
334 return SetStatus(DllExports::GdipRotateLineTransform(gradient, angle, order));
335 }
336
337 Status
339 {
340 GpLineGradient *gradient = GetNativeGradient();
341 return SetStatus(DllExports::GdipScaleLineTransform(gradient, sx, sy, order));
342 }
343
344 Status
345 SetBlend(const REAL *blendFactors, const REAL *blendPositions, INT count)
346 {
347 GpLineGradient *gradient = GetNativeGradient();
348 return SetStatus(DllExports::GdipSetLineBlend(gradient, blendFactors, blendPositions, count));
349 }
350
351 Status
353 {
354 GpLineGradient *gradient = GetNativeGradient();
355 return SetStatus(DllExports::GdipSetLineSigmaBlend(gradient, focus, scale));
356 }
357
358 Status
360 {
361 GpLineGradient *gradient = GetNativeGradient();
362 return SetStatus(DllExports::GdipSetLineLinearBlend(gradient, focus, scale));
363 }
364
365 Status
366 SetGammaCorrection(BOOL useGammaCorrection)
367 {
368 GpLineGradient *gradient = GetNativeGradient();
369 return SetStatus(DllExports::GdipSetLineGammaCorrection(gradient, useGammaCorrection));
370 }
371
372 Status
373 SetInterpolationColors(const Color *presetColors, const REAL *blendPositions, INT count)
374 {
376 }
377
378 Status
379 SetLinearColors(const Color &color1, const Color &color2)
380 {
381 GpLineGradient *gradient = GetNativeGradient();
382 return SetStatus(DllExports::GdipSetLineColors(gradient, color1.GetValue(), color2.GetValue()));
383 }
384
385 Status
387 {
388 GpLineGradient *gradient = GetNativeGradient();
389 return SetStatus(DllExports::GdipSetLineTransform(gradient, getNat(matrix)));
390 }
391
392 Status
394 {
395 GpLineGradient *gradient = GetNativeGradient();
396 return SetStatus(DllExports::GdipSetLineWrapMode(gradient, wrapMode));
397 }
398
399 Status
401 {
402 GpLineGradient *gradient = GetNativeGradient();
403 return SetStatus(DllExports::GdipTranslateLineTransform(gradient, dx, dy, order));
404 }
405
406 Status
407 SetLinearPoints(const PointF &point1, const PointF &point2)
408 {
409#if 1
411#else
412 GpLineGradient *gradient = GetNativeGradient();
413 return SetStatus(DllExports::GdipSetLinePoints(gradient, &point1, &point2));
414#endif
415 }
416
417 Status
419 {
420#if 1
422#else
423 GpLineGradient *gradient = GetNativeGradient();
424 return SetStatus(DllExports::GdipGetLinePoints(gradient, points));
425#endif
426 }
427
428 Status
429 SetLinearPoints(const Point &point1, const Point &point2)
430 {
431#if 1
433#else
434 GpLineGradient *gradient = GetNativeGradient();
435 return SetStatus(DllExports::GdipSetLinePointsI(gradient, &point1, &point2));
436#endif
437 }
438
439 Status
441 {
442#if 1
444#else
445 GpLineGradient *gradient = GetNativeGradient();
446 return SetStatus(DllExports::GdipGetLinePointsI(gradient, points));
447#endif
448 }
449
450 protected:
453 {
454 return static_cast<GpLineGradient *>(nativeBrush);
455 }
456};
457
459{
460 public:
461 friend class Pen;
462
464 {
465 GpSolidFill *brush = NULL;
466 lastStatus = DllExports::GdipCreateSolidFill(color.GetValue(), &brush);
467 SetNativeBrush(brush);
468 }
469
470 Status
472 {
473 if (!color)
475
476 ARGB argb;
478 SetStatus(DllExports::GdipGetSolidFillColor(fill, &argb));
479
480 *color = Color(argb);
481 return lastStatus;
482 }
483
484 Status
486 {
488 return SetStatus(DllExports::GdipSetSolidFillColor(fill, color.GetValue()));
489 }
490
491 protected:
493 {
494 }
495
498 {
499 return static_cast<GpSolidFill *>(nativeBrush);
500 }
501};
502
504{
505 public:
506 TextureBrush(Image *image, WrapMode wrapMode, const RectF &dstRect)
507 {
509 lastStatus = DllExports::GdipCreateTexture2(
510 getNat(image), wrapMode, dstRect.X, dstRect.Y, dstRect.Width, dstRect.Height, &texture);
512 }
513
514 TextureBrush(Image *image, Rect &dstRect, ImageAttributes *imageAttributes)
515 {
517 GpImageAttributes *attrs = imageAttributes ? getNat(imageAttributes) : NULL;
518 lastStatus = DllExports::GdipCreateTextureIA(
519 getNat(image), attrs, dstRect.X, dstRect.Y, dstRect.Width, dstRect.Height, &texture);
521 }
522
523 TextureBrush(Image *image, WrapMode wrapMode, INT dstX, INT dstY, INT dstWidth, INT dstHeight)
524 {
526 lastStatus =
527 DllExports::GdipCreateTexture2I(getNat(image), wrapMode, dstX, dstY, dstWidth, dstHeight, &texture);
529 }
530
531 TextureBrush(Image *image, WrapMode wrapMode, REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)
532 {
534 lastStatus = DllExports::GdipCreateTexture2(getNat(image), wrapMode, dstX, dstY, dstWidth, dstHeight, &texture);
536 }
537
538 TextureBrush(Image *image, RectF &dstRect, ImageAttributes *imageAttributes)
539 {
541 GpImageAttributes *attrs = imageAttributes ? getNat(imageAttributes) : NULL;
542 lastStatus = DllExports::GdipCreateTextureIA(
543 getNat(image), attrs, dstRect.X, dstRect.Y, dstRect.Width, dstRect.Height, &texture);
545 }
546
548 {
550 lastStatus = DllExports::GdipCreateTexture(getNat(image), wrapMode, &texture);
552 }
553
554 TextureBrush(Image *image, WrapMode wrapMode, const Rect &dstRect)
555 {
557 lastStatus = DllExports::GdipCreateTexture2I(
558 getNat(image), wrapMode, dstRect.X, dstRect.Y, dstRect.Width, dstRect.Height, &texture);
560 }
561
562 // Defined in "gdiplusheaders.h":
563 Image *
564 GetImage() const;
565
566 Status
568 {
570 return SetStatus(DllExports::GdipGetTextureTransform(texture, getNat(matrix)));
571 }
572
575 {
576 WrapMode wrapMode;
578 SetStatus(DllExports::GdipGetTextureWrapMode(texture, &wrapMode));
579 return wrapMode;
580 }
581
582 Status
584 {
586 return SetStatus(DllExports::GdipMultiplyTextureTransform(texture, getNat(matrix), order));
587 }
588
589 Status
591 {
593 return SetStatus(DllExports::GdipResetTextureTransform(texture));
594 }
595
596 Status
598 {
600 return SetStatus(DllExports::GdipRotateTextureTransform(texture, angle, order));
601 }
602
603 Status
605 {
607 return SetStatus(DllExports::GdipScaleTextureTransform(texture, sx, sy, order));
608 }
609
610 Status
612 {
614 return SetStatus(DllExports::GdipSetTextureTransform(texture, getNat(matrix)));
615 }
616
617 Status
619 {
621 return SetStatus(DllExports::GdipSetTextureWrapMode(texture, wrapMode));
622 }
623
624 Status
626 {
628 return SetStatus(DllExports::GdipTranslateTextureTransform(texture, dx, dy, order));
629 }
630
631 protected:
632 GpTexture *
634 {
635 return static_cast<GpTexture *>(nativeBrush);
636 }
637
639 {
640 }
641};
642
643#endif /* _GDIPLUSBRUSH_H */
_STLP_MOVE_TO_STD_NAMESPACE void fill(_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
Definition: _algobase.h:449
Status SetStatus(Status status) const
Definition: gdiplusbrush.h:76
Brush(const Brush &)
virtual ~Brush()
Definition: gdiplusbrush.h:28
friend GpBrush *& getNat(const Brush *brush)
Definition: gdiplusbrush.h:97
Status GetLastStatus() const
Definition: gdiplusbrush.h:50
Status lastStatus
Definition: gdiplusbrush.h:65
BrushType GetType() const
Definition: gdiplusbrush.h:56
GpBrush * nativeBrush
Definition: gdiplusbrush.h:64
Brush(GpBrush *brush, Status status)
Definition: gdiplusbrush.h:71
Brush * Clone() const
Definition: gdiplusbrush.h:34
Brush & operator=(const Brush &)
void SetNativeBrush(GpBrush *brush)
Definition: gdiplusbrush.h:84
HatchStyle GetHatchStyle() const
Definition: gdiplusbrush.h:144
Status GetBackgroundColor(Color *color) const
Definition: gdiplusbrush.h:116
GpHatch * GetNativeHatch() const
Definition: gdiplusbrush.h:158
HatchBrush(HatchStyle hatchStyle, const Color &foreColor, const Color &backColor)
Definition: gdiplusbrush.h:108
Status GetForegroundColor(Color *color) const
Definition: gdiplusbrush.h:130
Status SetLinearPoints(const Point &point1, const Point &point2)
Definition: gdiplusbrush.h:429
Status SetTransform(const Matrix *matrix)
Definition: gdiplusbrush.h:386
INT GetInterpolationColorCount() const
Definition: gdiplusbrush.h:253
LinearGradientBrush(const PointF &point1, const PointF &point2, const Color &color1, const Color &color2)
Definition: gdiplusbrush.h:169
BOOL GetGammaCorrection() const
Definition: gdiplusbrush.h:244
Status SetLinearPoints(const PointF &point1, const PointF &point2)
Definition: gdiplusbrush.h:407
Status SetInterpolationColors(const Color *presetColors, const REAL *blendPositions, INT count)
Definition: gdiplusbrush.h:373
Status GetLinearPoints(Point *points) const
Definition: gdiplusbrush.h:440
Status SetBlendBellShape(REAL focus, REAL scale)
Definition: gdiplusbrush.h:352
LinearGradientBrush(const Point &point1, const Point &point2, const Color &color1, const Color &color2)
Definition: gdiplusbrush.h:198
Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order=MatrixOrderPrepend)
Definition: gdiplusbrush.h:400
GpLineGradient * GetNativeGradient() const
Definition: gdiplusbrush.h:452
Status RotateTransform(REAL angle, MatrixOrder order)
Definition: gdiplusbrush.h:331
WrapMode GetWrapMode() const
Definition: gdiplusbrush.h:307
Status GetRectangle(Rect *rect) const
Definition: gdiplusbrush.h:286
Status GetLinearPoints(PointF *points) const
Definition: gdiplusbrush.h:418
Status SetBlend(const REAL *blendFactors, const REAL *blendPositions, INT count)
Definition: gdiplusbrush.h:345
Status SetGammaCorrection(BOOL useGammaCorrection)
Definition: gdiplusbrush.h:366
Status SetBlendTriangularShape(REAL focus, REAL scale=1.0f)
Definition: gdiplusbrush.h:359
LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, REAL angle, BOOL isAngleScalable=FALSE)
Definition: gdiplusbrush.h:206
INT GetBlendCount() const
Definition: gdiplusbrush.h:235
Status MultiplyTransform(const Matrix *matrix, MatrixOrder order)
Definition: gdiplusbrush.h:317
Status SetWrapMode(WrapMode wrapMode)
Definition: gdiplusbrush.h:393
LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
Definition: gdiplusbrush.h:190
Status GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count) const
Definition: gdiplusbrush.h:262
LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
Definition: gdiplusbrush.h:219
Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order=MatrixOrderPrepend)
Definition: gdiplusbrush.h:338
Status GetLinearColors(Color *colors) const
Definition: gdiplusbrush.h:268
Status GetTransform(Matrix *matrix) const
Definition: gdiplusbrush.h:300
Status SetLinearColors(const Color &color1, const Color &color2)
Definition: gdiplusbrush.h:379
LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, REAL angle, BOOL isAngleScalable=FALSE)
Definition: gdiplusbrush.h:177
Status GetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
Definition: gdiplusbrush.h:228
Status GetRectangle(RectF *rect) const
Definition: gdiplusbrush.h:293
Definition: gdipluspen.h:23
GpSolidFill * GetNativeFill() const
Definition: gdiplusbrush.h:497
Status SetColor(const Color &color)
Definition: gdiplusbrush.h:485
SolidBrush(const Color &color)
Definition: gdiplusbrush.h:463
Status GetColor(Color *color) const
Definition: gdiplusbrush.h:471
Status RotateTransform(REAL angle, MatrixOrder order)
Definition: gdiplusbrush.h:597
Status SetWrapMode(WrapMode wrapMode)
Definition: gdiplusbrush.h:618
Status MultiplyTransform(Matrix *matrix, MatrixOrder order=MatrixOrderPrepend)
Definition: gdiplusbrush.h:583
TextureBrush(Image *image, WrapMode wrapMode, REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)
Definition: gdiplusbrush.h:531
Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
Definition: gdiplusbrush.h:604
Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
Definition: gdiplusbrush.h:625
TextureBrush(Image *image, WrapMode wrapMode, const RectF &dstRect)
Definition: gdiplusbrush.h:506
TextureBrush(Image *image, Rect &dstRect, ImageAttributes *imageAttributes)
Definition: gdiplusbrush.h:514
WrapMode GetWrapMode() const
Definition: gdiplusbrush.h:574
Status ResetTransform()
Definition: gdiplusbrush.h:590
Image * GetImage() const
GpTexture * GetNativeTexture() const
Definition: gdiplusbrush.h:633
Status SetTransform(const Matrix *matrix)
Definition: gdiplusbrush.h:611
Status GetTransform(Matrix *matrix) const
Definition: gdiplusbrush.h:567
TextureBrush(Image *image, WrapMode wrapMode)
Definition: gdiplusbrush.h:547
TextureBrush(Image *image, WrapMode wrapMode, INT dstX, INT dstY, INT dstWidth, INT dstHeight)
Definition: gdiplusbrush.h:523
TextureBrush(Image *image, WrapMode wrapMode, const Rect &dstRect)
Definition: gdiplusbrush.h:554
TextureBrush(Image *image, RectF &dstRect, ImageAttributes *imageAttributes)
Definition: gdiplusbrush.h:538
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
float REAL
Definition: types.h:41
unsigned int BOOL
Definition: ntddk_ex.h:94
HatchStyle
Definition: gdiplusenums.h:390
WrapMode
Definition: gdiplusenums.h:206
@ WrapModeTile
Definition: gdiplusenums.h:207
MatrixOrder
Definition: gdiplusenums.h:187
@ MatrixOrderPrepend
Definition: gdiplusenums.h:188
BrushType
Definition: gdiplusenums.h:37
LinearGradientMode
Definition: gdiplusenums.h:225
DWORD ARGB
Status
Definition: gdiplustypes.h:25
@ Ok
Definition: gdiplustypes.h:26
@ InvalidParameter
Definition: gdiplustypes.h:28
@ NotImplemented
Definition: gdiplustypes.h:32
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLenum GLuint texture
Definition: glext.h:6295
GLenum GLint GLint GLint GLint GLuint GLenum GLint GLint GLint dstY
Definition: glext.h:11259
GLenum GLenum GLenum GLenum GLenum scale
Definition: glext.h:9032
GLuint color
Definition: glext.h:6243
GLenum GLint GLint GLint GLint GLuint GLenum GLint GLint dstX
Definition: glext.h:11259
GLuint GLenum matrix
Definition: glext.h:9407
GLenum mode
Definition: glext.h:6217
GLfloat angle
Definition: glext.h:10853
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
GLsizei const GLfloat * points
Definition: glext.h:8112
GLint dy
Definition: linetemp.h:97
GLint dx
Definition: linetemp.h:97
& rect
Definition: startmenu.cpp:1413
REAL Height
Definition: gdiplustypes.h:664
REAL X
Definition: gdiplustypes.h:661
REAL Width
Definition: gdiplustypes.h:663
REAL Y
Definition: gdiplustypes.h:662
INT Width
Definition: gdiplustypes.h:671
INT Height
Definition: gdiplustypes.h:672
INT X
Definition: gdiplustypes.h:669
INT Y
Definition: gdiplustypes.h:670
Definition: ps.c:97
int32_t INT
Definition: typedefs.h:58