1#![cfg(windows)]
2#![allow(non_upper_case_globals, non_camel_case_types, non_snake_case)]
3#![cfg_attr(not(test), no_std)]
4
5use core::mem::MaybeUninit;
6
7pub use winapi::ctypes::{c_int, c_void};
8pub use winapi::shared::basetsd::{INT16, UINT16, UINT32, UINT_PTR, ULONG_PTR};
9pub use winapi::shared::guiddef::{CLSID, GUID};
10pub use winapi::shared::minwindef::{
11 BOOL, BYTE, DWORD, HINSTANCE, HMETAFILE, HRGN, LPBYTE, UINT, WORD,
12};
13pub use winapi::shared::ntdef::{CHAR, HANDLE, INT, LANGID, LPWSTR, ULONG, WCHAR};
14pub use winapi::shared::windef::{
15 HBITMAP, HDC, HENHMETAFILE, HFONT, HICON, HPALETTE, HWND, RECTL, SIZEL,
16};
17pub use winapi::shared::wtypes::PROPID;
18pub use winapi::um::commctrl::IStream;
19pub use winapi::um::wingdi::{BITMAPINFO, LOGFONTA, LOGFONTW, METAHEADER};
20pub use winapi::vc::vcruntime::size_t;
21
22#[cfg(test)]
23mod bindgen_tests;
24
25#[repr(C)]
26#[derive(Debug, Copy, Clone)]
27pub struct IDirectDrawSurface7 {
28 _unused: [u8; 0],
29}
30extern "C" {
31 #[link_name = "\u{1}GdipAlloc"]
32 pub fn GdipAlloc(size: size_t) -> *mut c_void;
33}
34extern "C" {
35 #[link_name = "\u{1}GdipFree"]
36 pub fn GdipFree(ptr: *mut c_void);
37}
38extern "C" {
39 #[link_name = "\u{1}GdipCreatePath"]
40 pub fn GdipCreatePath(brushMode: GpFillMode, path: *mut *mut GpPath) -> GpStatus;
41}
42extern "C" {
43 #[link_name = "\u{1}GdipCreatePath2"]
44 pub fn GdipCreatePath2(
45 arg1: *const GpPointF,
46 arg2: *const BYTE,
47 arg3: INT,
48 arg4: GpFillMode,
49 path: *mut *mut GpPath,
50 ) -> GpStatus;
51}
52extern "C" {
53 #[link_name = "\u{1}GdipCreatePath2I"]
54 pub fn GdipCreatePath2I(
55 arg1: *const GpPoint,
56 arg2: *const BYTE,
57 arg3: INT,
58 arg4: GpFillMode,
59 path: *mut *mut GpPath,
60 ) -> GpStatus;
61}
62extern "C" {
63 #[link_name = "\u{1}GdipClonePath"]
64 pub fn GdipClonePath(path: *mut GpPath, clonePath: *mut *mut GpPath) -> GpStatus;
65}
66extern "C" {
67 #[link_name = "\u{1}GdipDeletePath"]
68 pub fn GdipDeletePath(path: *mut GpPath) -> GpStatus;
69}
70extern "C" {
71 #[link_name = "\u{1}GdipResetPath"]
72 pub fn GdipResetPath(path: *mut GpPath) -> GpStatus;
73}
74extern "C" {
75 #[link_name = "\u{1}GdipGetPointCount"]
76 pub fn GdipGetPointCount(path: *mut GpPath, count: *mut INT) -> GpStatus;
77}
78extern "C" {
79 #[link_name = "\u{1}GdipGetPathTypes"]
80 pub fn GdipGetPathTypes(path: *mut GpPath, types: *mut BYTE, count: INT) -> GpStatus;
81}
82extern "C" {
83 #[link_name = "\u{1}GdipGetPathPoints"]
84 pub fn GdipGetPathPoints(arg1: *mut GpPath, points: *mut GpPointF, count: INT) -> GpStatus;
85}
86extern "C" {
87 #[link_name = "\u{1}GdipGetPathPointsI"]
88 pub fn GdipGetPathPointsI(arg1: *mut GpPath, points: *mut GpPoint, count: INT) -> GpStatus;
89}
90extern "C" {
91 #[link_name = "\u{1}GdipGetPathFillMode"]
92 pub fn GdipGetPathFillMode(path: *mut GpPath, fillmode: *mut GpFillMode) -> GpStatus;
93}
94extern "C" {
95 #[link_name = "\u{1}GdipSetPathFillMode"]
96 pub fn GdipSetPathFillMode(path: *mut GpPath, fillmode: GpFillMode) -> GpStatus;
97}
98extern "C" {
99 #[link_name = "\u{1}GdipGetPathData"]
100 pub fn GdipGetPathData(path: *mut GpPath, pathData: *mut GpPathData) -> GpStatus;
101}
102extern "C" {
103 #[link_name = "\u{1}GdipStartPathFigure"]
104 pub fn GdipStartPathFigure(path: *mut GpPath) -> GpStatus;
105}
106extern "C" {
107 #[link_name = "\u{1}GdipClosePathFigure"]
108 pub fn GdipClosePathFigure(path: *mut GpPath) -> GpStatus;
109}
110extern "C" {
111 #[link_name = "\u{1}GdipClosePathFigures"]
112 pub fn GdipClosePathFigures(path: *mut GpPath) -> GpStatus;
113}
114extern "C" {
115 #[link_name = "\u{1}GdipSetPathMarker"]
116 pub fn GdipSetPathMarker(path: *mut GpPath) -> GpStatus;
117}
118extern "C" {
119 #[link_name = "\u{1}GdipClearPathMarkers"]
120 pub fn GdipClearPathMarkers(path: *mut GpPath) -> GpStatus;
121}
122extern "C" {
123 #[link_name = "\u{1}GdipReversePath"]
124 pub fn GdipReversePath(path: *mut GpPath) -> GpStatus;
125}
126extern "C" {
127 #[link_name = "\u{1}GdipGetPathLastPoint"]
128 pub fn GdipGetPathLastPoint(path: *mut GpPath, lastPoint: *mut GpPointF) -> GpStatus;
129}
130extern "C" {
131 #[link_name = "\u{1}GdipAddPathLine"]
132 pub fn GdipAddPathLine(path: *mut GpPath, x1: REAL, y1: REAL, x2: REAL, y2: REAL) -> GpStatus;
133}
134extern "C" {
135 #[link_name = "\u{1}GdipAddPathLine2"]
136 pub fn GdipAddPathLine2(path: *mut GpPath, points: *const GpPointF, count: INT) -> GpStatus;
137}
138extern "C" {
139 #[link_name = "\u{1}GdipAddPathArc"]
140 pub fn GdipAddPathArc(
141 path: *mut GpPath,
142 x: REAL,
143 y: REAL,
144 width: REAL,
145 height: REAL,
146 startAngle: REAL,
147 sweepAngle: REAL,
148 ) -> GpStatus;
149}
150extern "C" {
151 #[link_name = "\u{1}GdipAddPathBezier"]
152 pub fn GdipAddPathBezier(
153 path: *mut GpPath,
154 x1: REAL,
155 y1: REAL,
156 x2: REAL,
157 y2: REAL,
158 x3: REAL,
159 y3: REAL,
160 x4: REAL,
161 y4: REAL,
162 ) -> GpStatus;
163}
164extern "C" {
165 #[link_name = "\u{1}GdipAddPathBeziers"]
166 pub fn GdipAddPathBeziers(path: *mut GpPath, points: *const GpPointF, count: INT) -> GpStatus;
167}
168extern "C" {
169 #[link_name = "\u{1}GdipAddPathCurve"]
170 pub fn GdipAddPathCurve(path: *mut GpPath, points: *const GpPointF, count: INT) -> GpStatus;
171}
172extern "C" {
173 #[link_name = "\u{1}GdipAddPathCurve2"]
174 pub fn GdipAddPathCurve2(
175 path: *mut GpPath,
176 points: *const GpPointF,
177 count: INT,
178 tension: REAL,
179 ) -> GpStatus;
180}
181extern "C" {
182 #[link_name = "\u{1}GdipAddPathCurve3"]
183 pub fn GdipAddPathCurve3(
184 path: *mut GpPath,
185 points: *const GpPointF,
186 count: INT,
187 offset: INT,
188 numberOfSegments: INT,
189 tension: REAL,
190 ) -> GpStatus;
191}
192extern "C" {
193 #[link_name = "\u{1}GdipAddPathClosedCurve"]
194 pub fn GdipAddPathClosedCurve(
195 path: *mut GpPath,
196 points: *const GpPointF,
197 count: INT,
198 ) -> GpStatus;
199}
200extern "C" {
201 #[link_name = "\u{1}GdipAddPathClosedCurve2"]
202 pub fn GdipAddPathClosedCurve2(
203 path: *mut GpPath,
204 points: *const GpPointF,
205 count: INT,
206 tension: REAL,
207 ) -> GpStatus;
208}
209extern "C" {
210 #[link_name = "\u{1}GdipAddPathRectangle"]
211 pub fn GdipAddPathRectangle(
212 path: *mut GpPath,
213 x: REAL,
214 y: REAL,
215 width: REAL,
216 height: REAL,
217 ) -> GpStatus;
218}
219extern "C" {
220 #[link_name = "\u{1}GdipAddPathRectangles"]
221 pub fn GdipAddPathRectangles(path: *mut GpPath, rects: *const GpRectF, count: INT) -> GpStatus;
222}
223extern "C" {
224 #[link_name = "\u{1}GdipAddPathEllipse"]
225 pub fn GdipAddPathEllipse(
226 path: *mut GpPath,
227 x: REAL,
228 y: REAL,
229 width: REAL,
230 height: REAL,
231 ) -> GpStatus;
232}
233extern "C" {
234 #[link_name = "\u{1}GdipAddPathPie"]
235 pub fn GdipAddPathPie(
236 path: *mut GpPath,
237 x: REAL,
238 y: REAL,
239 width: REAL,
240 height: REAL,
241 startAngle: REAL,
242 sweepAngle: REAL,
243 ) -> GpStatus;
244}
245extern "C" {
246 #[link_name = "\u{1}GdipAddPathPolygon"]
247 pub fn GdipAddPathPolygon(path: *mut GpPath, points: *const GpPointF, count: INT) -> GpStatus;
248}
249extern "C" {
250 #[link_name = "\u{1}GdipAddPathPath"]
251 pub fn GdipAddPathPath(path: *mut GpPath, addingPath: *const GpPath, connect: BOOL)
252 -> GpStatus;
253}
254extern "C" {
255 #[link_name = "\u{1}GdipAddPathString"]
256 pub fn GdipAddPathString(
257 path: *mut GpPath,
258 string: *const WCHAR,
259 length: INT,
260 family: *const GpFontFamily,
261 style: INT,
262 emSize: REAL,
263 layoutRect: *const RectF,
264 format: *const GpStringFormat,
265 ) -> GpStatus;
266}
267extern "C" {
268 #[link_name = "\u{1}GdipAddPathStringI"]
269 pub fn GdipAddPathStringI(
270 path: *mut GpPath,
271 string: *const WCHAR,
272 length: INT,
273 family: *const GpFontFamily,
274 style: INT,
275 emSize: REAL,
276 layoutRect: *const Rect,
277 format: *const GpStringFormat,
278 ) -> GpStatus;
279}
280extern "C" {
281 #[link_name = "\u{1}GdipAddPathLineI"]
282 pub fn GdipAddPathLineI(path: *mut GpPath, x1: INT, y1: INT, x2: INT, y2: INT) -> GpStatus;
283}
284extern "C" {
285 #[link_name = "\u{1}GdipAddPathLine2I"]
286 pub fn GdipAddPathLine2I(path: *mut GpPath, points: *const GpPoint, count: INT) -> GpStatus;
287}
288extern "C" {
289 #[link_name = "\u{1}GdipAddPathArcI"]
290 pub fn GdipAddPathArcI(
291 path: *mut GpPath,
292 x: INT,
293 y: INT,
294 width: INT,
295 height: INT,
296 startAngle: REAL,
297 sweepAngle: REAL,
298 ) -> GpStatus;
299}
300extern "C" {
301 #[link_name = "\u{1}GdipAddPathBezierI"]
302 pub fn GdipAddPathBezierI(
303 path: *mut GpPath,
304 x1: INT,
305 y1: INT,
306 x2: INT,
307 y2: INT,
308 x3: INT,
309 y3: INT,
310 x4: INT,
311 y4: INT,
312 ) -> GpStatus;
313}
314extern "C" {
315 #[link_name = "\u{1}GdipAddPathBeziersI"]
316 pub fn GdipAddPathBeziersI(path: *mut GpPath, points: *const GpPoint, count: INT) -> GpStatus;
317}
318extern "C" {
319 #[link_name = "\u{1}GdipAddPathCurveI"]
320 pub fn GdipAddPathCurveI(path: *mut GpPath, points: *const GpPoint, count: INT) -> GpStatus;
321}
322extern "C" {
323 #[link_name = "\u{1}GdipAddPathCurve2I"]
324 pub fn GdipAddPathCurve2I(
325 path: *mut GpPath,
326 points: *const GpPoint,
327 count: INT,
328 tension: REAL,
329 ) -> GpStatus;
330}
331extern "C" {
332 #[link_name = "\u{1}GdipAddPathCurve3I"]
333 pub fn GdipAddPathCurve3I(
334 path: *mut GpPath,
335 points: *const GpPoint,
336 count: INT,
337 offset: INT,
338 numberOfSegments: INT,
339 tension: REAL,
340 ) -> GpStatus;
341}
342extern "C" {
343 #[link_name = "\u{1}GdipAddPathClosedCurveI"]
344 pub fn GdipAddPathClosedCurveI(
345 path: *mut GpPath,
346 points: *const GpPoint,
347 count: INT,
348 ) -> GpStatus;
349}
350extern "C" {
351 #[link_name = "\u{1}GdipAddPathClosedCurve2I"]
352 pub fn GdipAddPathClosedCurve2I(
353 path: *mut GpPath,
354 points: *const GpPoint,
355 count: INT,
356 tension: REAL,
357 ) -> GpStatus;
358}
359extern "C" {
360 #[link_name = "\u{1}GdipAddPathRectangleI"]
361 pub fn GdipAddPathRectangleI(
362 path: *mut GpPath,
363 x: INT,
364 y: INT,
365 width: INT,
366 height: INT,
367 ) -> GpStatus;
368}
369extern "C" {
370 #[link_name = "\u{1}GdipAddPathRectanglesI"]
371 pub fn GdipAddPathRectanglesI(path: *mut GpPath, rects: *const GpRect, count: INT) -> GpStatus;
372}
373extern "C" {
374 #[link_name = "\u{1}GdipAddPathEllipseI"]
375 pub fn GdipAddPathEllipseI(
376 path: *mut GpPath,
377 x: INT,
378 y: INT,
379 width: INT,
380 height: INT,
381 ) -> GpStatus;
382}
383extern "C" {
384 #[link_name = "\u{1}GdipAddPathPieI"]
385 pub fn GdipAddPathPieI(
386 path: *mut GpPath,
387 x: INT,
388 y: INT,
389 width: INT,
390 height: INT,
391 startAngle: REAL,
392 sweepAngle: REAL,
393 ) -> GpStatus;
394}
395extern "C" {
396 #[link_name = "\u{1}GdipAddPathPolygonI"]
397 pub fn GdipAddPathPolygonI(path: *mut GpPath, points: *const GpPoint, count: INT) -> GpStatus;
398}
399extern "C" {
400 #[link_name = "\u{1}GdipFlattenPath"]
401 pub fn GdipFlattenPath(path: *mut GpPath, matrix: *mut GpMatrix, flatness: REAL) -> GpStatus;
402}
403extern "C" {
404 #[link_name = "\u{1}GdipWindingModeOutline"]
405 pub fn GdipWindingModeOutline(
406 path: *mut GpPath,
407 matrix: *mut GpMatrix,
408 flatness: REAL,
409 ) -> GpStatus;
410}
411extern "C" {
412 #[link_name = "\u{1}GdipWidenPath"]
413 pub fn GdipWidenPath(
414 nativePath: *mut GpPath,
415 pen: *mut GpPen,
416 matrix: *mut GpMatrix,
417 flatness: REAL,
418 ) -> GpStatus;
419}
420extern "C" {
421 #[link_name = "\u{1}GdipWarpPath"]
422 pub fn GdipWarpPath(
423 path: *mut GpPath,
424 matrix: *mut GpMatrix,
425 points: *const GpPointF,
426 count: INT,
427 srcx: REAL,
428 srcy: REAL,
429 srcwidth: REAL,
430 srcheight: REAL,
431 warpMode: WarpMode,
432 flatness: REAL,
433 ) -> GpStatus;
434}
435extern "C" {
436 #[link_name = "\u{1}GdipTransformPath"]
437 pub fn GdipTransformPath(path: *mut GpPath, matrix: *mut GpMatrix) -> GpStatus;
438}
439extern "C" {
440 #[link_name = "\u{1}GdipGetPathWorldBounds"]
441 pub fn GdipGetPathWorldBounds(
442 path: *mut GpPath,
443 bounds: *mut GpRectF,
444 matrix: *const GpMatrix,
445 pen: *const GpPen,
446 ) -> GpStatus;
447}
448extern "C" {
449 #[link_name = "\u{1}GdipGetPathWorldBoundsI"]
450 pub fn GdipGetPathWorldBoundsI(
451 path: *mut GpPath,
452 bounds: *mut GpRect,
453 matrix: *const GpMatrix,
454 pen: *const GpPen,
455 ) -> GpStatus;
456}
457extern "C" {
458 #[link_name = "\u{1}GdipIsVisiblePathPoint"]
459 pub fn GdipIsVisiblePathPoint(
460 path: *mut GpPath,
461 x: REAL,
462 y: REAL,
463 graphics: *mut GpGraphics,
464 result: *mut BOOL,
465 ) -> GpStatus;
466}
467extern "C" {
468 #[link_name = "\u{1}GdipIsVisiblePathPointI"]
469 pub fn GdipIsVisiblePathPointI(
470 path: *mut GpPath,
471 x: INT,
472 y: INT,
473 graphics: *mut GpGraphics,
474 result: *mut BOOL,
475 ) -> GpStatus;
476}
477extern "C" {
478 #[link_name = "\u{1}GdipIsOutlineVisiblePathPoint"]
479 pub fn GdipIsOutlineVisiblePathPoint(
480 path: *mut GpPath,
481 x: REAL,
482 y: REAL,
483 pen: *mut GpPen,
484 graphics: *mut GpGraphics,
485 result: *mut BOOL,
486 ) -> GpStatus;
487}
488extern "C" {
489 #[link_name = "\u{1}GdipIsOutlineVisiblePathPointI"]
490 pub fn GdipIsOutlineVisiblePathPointI(
491 path: *mut GpPath,
492 x: INT,
493 y: INT,
494 pen: *mut GpPen,
495 graphics: *mut GpGraphics,
496 result: *mut BOOL,
497 ) -> GpStatus;
498}
499extern "C" {
500 #[link_name = "\u{1}GdipCreatePathIter"]
501 pub fn GdipCreatePathIter(iterator: *mut *mut GpPathIterator, path: *mut GpPath) -> GpStatus;
502}
503extern "C" {
504 #[link_name = "\u{1}GdipDeletePathIter"]
505 pub fn GdipDeletePathIter(iterator: *mut GpPathIterator) -> GpStatus;
506}
507extern "C" {
508 #[link_name = "\u{1}GdipPathIterNextSubpath"]
509 pub fn GdipPathIterNextSubpath(
510 iterator: *mut GpPathIterator,
511 resultCount: *mut INT,
512 startIndex: *mut INT,
513 endIndex: *mut INT,
514 isClosed: *mut BOOL,
515 ) -> GpStatus;
516}
517extern "C" {
518 #[link_name = "\u{1}GdipPathIterNextSubpathPath"]
519 pub fn GdipPathIterNextSubpathPath(
520 iterator: *mut GpPathIterator,
521 resultCount: *mut INT,
522 path: *mut GpPath,
523 isClosed: *mut BOOL,
524 ) -> GpStatus;
525}
526extern "C" {
527 #[link_name = "\u{1}GdipPathIterNextPathType"]
528 pub fn GdipPathIterNextPathType(
529 iterator: *mut GpPathIterator,
530 resultCount: *mut INT,
531 pathType: *mut BYTE,
532 startIndex: *mut INT,
533 endIndex: *mut INT,
534 ) -> GpStatus;
535}
536extern "C" {
537 #[link_name = "\u{1}GdipPathIterNextMarker"]
538 pub fn GdipPathIterNextMarker(
539 iterator: *mut GpPathIterator,
540 resultCount: *mut INT,
541 startIndex: *mut INT,
542 endIndex: *mut INT,
543 ) -> GpStatus;
544}
545extern "C" {
546 #[link_name = "\u{1}GdipPathIterNextMarkerPath"]
547 pub fn GdipPathIterNextMarkerPath(
548 iterator: *mut GpPathIterator,
549 resultCount: *mut INT,
550 path: *mut GpPath,
551 ) -> GpStatus;
552}
553extern "C" {
554 #[link_name = "\u{1}GdipPathIterGetCount"]
555 pub fn GdipPathIterGetCount(iterator: *mut GpPathIterator, count: *mut INT) -> GpStatus;
556}
557extern "C" {
558 #[link_name = "\u{1}GdipPathIterGetSubpathCount"]
559 pub fn GdipPathIterGetSubpathCount(iterator: *mut GpPathIterator, count: *mut INT) -> GpStatus;
560}
561extern "C" {
562 #[link_name = "\u{1}GdipPathIterIsValid"]
563 pub fn GdipPathIterIsValid(iterator: *mut GpPathIterator, valid: *mut BOOL) -> GpStatus;
564}
565extern "C" {
566 #[link_name = "\u{1}GdipPathIterHasCurve"]
567 pub fn GdipPathIterHasCurve(iterator: *mut GpPathIterator, hasCurve: *mut BOOL) -> GpStatus;
568}
569extern "C" {
570 #[link_name = "\u{1}GdipPathIterRewind"]
571 pub fn GdipPathIterRewind(iterator: *mut GpPathIterator) -> GpStatus;
572}
573extern "C" {
574 #[link_name = "\u{1}GdipPathIterEnumerate"]
575 pub fn GdipPathIterEnumerate(
576 iterator: *mut GpPathIterator,
577 resultCount: *mut INT,
578 points: *mut GpPointF,
579 types: *mut BYTE,
580 count: INT,
581 ) -> GpStatus;
582}
583extern "C" {
584 #[link_name = "\u{1}GdipPathIterCopyData"]
585 pub fn GdipPathIterCopyData(
586 iterator: *mut GpPathIterator,
587 resultCount: *mut INT,
588 points: *mut GpPointF,
589 types: *mut BYTE,
590 startIndex: INT,
591 endIndex: INT,
592 ) -> GpStatus;
593}
594extern "C" {
595 #[link_name = "\u{1}GdipCreateMatrix"]
596 pub fn GdipCreateMatrix(matrix: *mut *mut GpMatrix) -> GpStatus;
597}
598extern "C" {
599 #[link_name = "\u{1}GdipCreateMatrix2"]
600 pub fn GdipCreateMatrix2(
601 m11: REAL,
602 m12: REAL,
603 m21: REAL,
604 m22: REAL,
605 dx: REAL,
606 dy: REAL,
607 matrix: *mut *mut GpMatrix,
608 ) -> GpStatus;
609}
610extern "C" {
611 #[link_name = "\u{1}GdipCreateMatrix3"]
612 pub fn GdipCreateMatrix3(
613 rect: *const GpRectF,
614 dstplg: *const GpPointF,
615 matrix: *mut *mut GpMatrix,
616 ) -> GpStatus;
617}
618extern "C" {
619 #[link_name = "\u{1}GdipCreateMatrix3I"]
620 pub fn GdipCreateMatrix3I(
621 rect: *const GpRect,
622 dstplg: *const GpPoint,
623 matrix: *mut *mut GpMatrix,
624 ) -> GpStatus;
625}
626extern "C" {
627 #[link_name = "\u{1}GdipCloneMatrix"]
628 pub fn GdipCloneMatrix(matrix: *mut GpMatrix, cloneMatrix: *mut *mut GpMatrix) -> GpStatus;
629}
630extern "C" {
631 #[link_name = "\u{1}GdipDeleteMatrix"]
632 pub fn GdipDeleteMatrix(matrix: *mut GpMatrix) -> GpStatus;
633}
634extern "C" {
635 #[link_name = "\u{1}GdipSetMatrixElements"]
636 pub fn GdipSetMatrixElements(
637 matrix: *mut GpMatrix,
638 m11: REAL,
639 m12: REAL,
640 m21: REAL,
641 m22: REAL,
642 dx: REAL,
643 dy: REAL,
644 ) -> GpStatus;
645}
646extern "C" {
647 #[link_name = "\u{1}GdipMultiplyMatrix"]
648 pub fn GdipMultiplyMatrix(
649 matrix: *mut GpMatrix,
650 matrix2: *mut GpMatrix,
651 order: GpMatrixOrder,
652 ) -> GpStatus;
653}
654extern "C" {
655 #[link_name = "\u{1}GdipTranslateMatrix"]
656 pub fn GdipTranslateMatrix(
657 matrix: *mut GpMatrix,
658 offsetX: REAL,
659 offsetY: REAL,
660 order: GpMatrixOrder,
661 ) -> GpStatus;
662}
663extern "C" {
664 #[link_name = "\u{1}GdipScaleMatrix"]
665 pub fn GdipScaleMatrix(
666 matrix: *mut GpMatrix,
667 scaleX: REAL,
668 scaleY: REAL,
669 order: GpMatrixOrder,
670 ) -> GpStatus;
671}
672extern "C" {
673 #[link_name = "\u{1}GdipRotateMatrix"]
674 pub fn GdipRotateMatrix(matrix: *mut GpMatrix, angle: REAL, order: GpMatrixOrder) -> GpStatus;
675}
676extern "C" {
677 #[link_name = "\u{1}GdipShearMatrix"]
678 pub fn GdipShearMatrix(
679 matrix: *mut GpMatrix,
680 shearX: REAL,
681 shearY: REAL,
682 order: GpMatrixOrder,
683 ) -> GpStatus;
684}
685extern "C" {
686 #[link_name = "\u{1}GdipInvertMatrix"]
687 pub fn GdipInvertMatrix(matrix: *mut GpMatrix) -> GpStatus;
688}
689extern "C" {
690 #[link_name = "\u{1}GdipTransformMatrixPoints"]
691 pub fn GdipTransformMatrixPoints(
692 matrix: *mut GpMatrix,
693 pts: *mut GpPointF,
694 count: INT,
695 ) -> GpStatus;
696}
697extern "C" {
698 #[link_name = "\u{1}GdipTransformMatrixPointsI"]
699 pub fn GdipTransformMatrixPointsI(
700 matrix: *mut GpMatrix,
701 pts: *mut GpPoint,
702 count: INT,
703 ) -> GpStatus;
704}
705extern "C" {
706 #[link_name = "\u{1}GdipVectorTransformMatrixPoints"]
707 pub fn GdipVectorTransformMatrixPoints(
708 matrix: *mut GpMatrix,
709 pts: *mut GpPointF,
710 count: INT,
711 ) -> GpStatus;
712}
713extern "C" {
714 #[link_name = "\u{1}GdipVectorTransformMatrixPointsI"]
715 pub fn GdipVectorTransformMatrixPointsI(
716 matrix: *mut GpMatrix,
717 pts: *mut GpPoint,
718 count: INT,
719 ) -> GpStatus;
720}
721extern "C" {
722 #[link_name = "\u{1}GdipGetMatrixElements"]
723 pub fn GdipGetMatrixElements(matrix: *const GpMatrix, matrixOut: *mut REAL) -> GpStatus;
724}
725extern "C" {
726 #[link_name = "\u{1}GdipIsMatrixInvertible"]
727 pub fn GdipIsMatrixInvertible(matrix: *const GpMatrix, result: *mut BOOL) -> GpStatus;
728}
729extern "C" {
730 #[link_name = "\u{1}GdipIsMatrixIdentity"]
731 pub fn GdipIsMatrixIdentity(matrix: *const GpMatrix, result: *mut BOOL) -> GpStatus;
732}
733extern "C" {
734 #[link_name = "\u{1}GdipIsMatrixEqual"]
735 pub fn GdipIsMatrixEqual(
736 matrix: *const GpMatrix,
737 matrix2: *const GpMatrix,
738 result: *mut BOOL,
739 ) -> GpStatus;
740}
741extern "C" {
742 #[link_name = "\u{1}GdipCreateRegion"]
743 pub fn GdipCreateRegion(region: *mut *mut GpRegion) -> GpStatus;
744}
745extern "C" {
746 #[link_name = "\u{1}GdipCreateRegionRect"]
747 pub fn GdipCreateRegionRect(rect: *const GpRectF, region: *mut *mut GpRegion) -> GpStatus;
748}
749extern "C" {
750 #[link_name = "\u{1}GdipCreateRegionRectI"]
751 pub fn GdipCreateRegionRectI(rect: *const GpRect, region: *mut *mut GpRegion) -> GpStatus;
752}
753extern "C" {
754 #[link_name = "\u{1}GdipCreateRegionPath"]
755 pub fn GdipCreateRegionPath(path: *mut GpPath, region: *mut *mut GpRegion) -> GpStatus;
756}
757extern "C" {
758 #[link_name = "\u{1}GdipCreateRegionRgnData"]
759 pub fn GdipCreateRegionRgnData(
760 regionData: *const BYTE,
761 size: INT,
762 region: *mut *mut GpRegion,
763 ) -> GpStatus;
764}
765extern "C" {
766 #[link_name = "\u{1}GdipCreateRegionHrgn"]
767 pub fn GdipCreateRegionHrgn(hRgn: HRGN, region: *mut *mut GpRegion) -> GpStatus;
768}
769extern "C" {
770 #[link_name = "\u{1}GdipCloneRegion"]
771 pub fn GdipCloneRegion(region: *mut GpRegion, cloneRegion: *mut *mut GpRegion) -> GpStatus;
772}
773extern "C" {
774 #[link_name = "\u{1}GdipDeleteRegion"]
775 pub fn GdipDeleteRegion(region: *mut GpRegion) -> GpStatus;
776}
777extern "C" {
778 #[link_name = "\u{1}GdipSetInfinite"]
779 pub fn GdipSetInfinite(region: *mut GpRegion) -> GpStatus;
780}
781extern "C" {
782 #[link_name = "\u{1}GdipSetEmpty"]
783 pub fn GdipSetEmpty(region: *mut GpRegion) -> GpStatus;
784}
785extern "C" {
786 #[link_name = "\u{1}GdipCombineRegionRect"]
787 pub fn GdipCombineRegionRect(
788 region: *mut GpRegion,
789 rect: *const GpRectF,
790 combineMode: CombineMode,
791 ) -> GpStatus;
792}
793extern "C" {
794 #[link_name = "\u{1}GdipCombineRegionRectI"]
795 pub fn GdipCombineRegionRectI(
796 region: *mut GpRegion,
797 rect: *const GpRect,
798 combineMode: CombineMode,
799 ) -> GpStatus;
800}
801extern "C" {
802 #[link_name = "\u{1}GdipCombineRegionPath"]
803 pub fn GdipCombineRegionPath(
804 region: *mut GpRegion,
805 path: *mut GpPath,
806 combineMode: CombineMode,
807 ) -> GpStatus;
808}
809extern "C" {
810 #[link_name = "\u{1}GdipCombineRegionRegion"]
811 pub fn GdipCombineRegionRegion(
812 region: *mut GpRegion,
813 region2: *mut GpRegion,
814 combineMode: CombineMode,
815 ) -> GpStatus;
816}
817extern "C" {
818 #[link_name = "\u{1}GdipTranslateRegion"]
819 pub fn GdipTranslateRegion(region: *mut GpRegion, dx: REAL, dy: REAL) -> GpStatus;
820}
821extern "C" {
822 #[link_name = "\u{1}GdipTranslateRegionI"]
823 pub fn GdipTranslateRegionI(region: *mut GpRegion, dx: INT, dy: INT) -> GpStatus;
824}
825extern "C" {
826 #[link_name = "\u{1}GdipTransformRegion"]
827 pub fn GdipTransformRegion(region: *mut GpRegion, matrix: *mut GpMatrix) -> GpStatus;
828}
829extern "C" {
830 #[link_name = "\u{1}GdipGetRegionBounds"]
831 pub fn GdipGetRegionBounds(
832 region: *mut GpRegion,
833 graphics: *mut GpGraphics,
834 rect: *mut GpRectF,
835 ) -> GpStatus;
836}
837extern "C" {
838 #[link_name = "\u{1}GdipGetRegionBoundsI"]
839 pub fn GdipGetRegionBoundsI(
840 region: *mut GpRegion,
841 graphics: *mut GpGraphics,
842 rect: *mut GpRect,
843 ) -> GpStatus;
844}
845extern "C" {
846 #[link_name = "\u{1}GdipGetRegionHRgn"]
847 pub fn GdipGetRegionHRgn(
848 region: *mut GpRegion,
849 graphics: *mut GpGraphics,
850 hRgn: *mut HRGN,
851 ) -> GpStatus;
852}
853extern "C" {
854 #[link_name = "\u{1}GdipIsEmptyRegion"]
855 pub fn GdipIsEmptyRegion(
856 region: *mut GpRegion,
857 graphics: *mut GpGraphics,
858 result: *mut BOOL,
859 ) -> GpStatus;
860}
861extern "C" {
862 #[link_name = "\u{1}GdipIsInfiniteRegion"]
863 pub fn GdipIsInfiniteRegion(
864 region: *mut GpRegion,
865 graphics: *mut GpGraphics,
866 result: *mut BOOL,
867 ) -> GpStatus;
868}
869extern "C" {
870 #[link_name = "\u{1}GdipIsEqualRegion"]
871 pub fn GdipIsEqualRegion(
872 region: *mut GpRegion,
873 region2: *mut GpRegion,
874 graphics: *mut GpGraphics,
875 result: *mut BOOL,
876 ) -> GpStatus;
877}
878extern "C" {
879 #[link_name = "\u{1}GdipGetRegionDataSize"]
880 pub fn GdipGetRegionDataSize(region: *mut GpRegion, bufferSize: *mut UINT) -> GpStatus;
881}
882extern "C" {
883 #[link_name = "\u{1}GdipGetRegionData"]
884 pub fn GdipGetRegionData(
885 region: *mut GpRegion,
886 buffer: *mut BYTE,
887 bufferSize: UINT,
888 sizeFilled: *mut UINT,
889 ) -> GpStatus;
890}
891extern "C" {
892 #[link_name = "\u{1}GdipIsVisibleRegionPoint"]
893 pub fn GdipIsVisibleRegionPoint(
894 region: *mut GpRegion,
895 x: REAL,
896 y: REAL,
897 graphics: *mut GpGraphics,
898 result: *mut BOOL,
899 ) -> GpStatus;
900}
901extern "C" {
902 #[link_name = "\u{1}GdipIsVisibleRegionPointI"]
903 pub fn GdipIsVisibleRegionPointI(
904 region: *mut GpRegion,
905 x: INT,
906 y: INT,
907 graphics: *mut GpGraphics,
908 result: *mut BOOL,
909 ) -> GpStatus;
910}
911extern "C" {
912 #[link_name = "\u{1}GdipIsVisibleRegionRect"]
913 pub fn GdipIsVisibleRegionRect(
914 region: *mut GpRegion,
915 x: REAL,
916 y: REAL,
917 width: REAL,
918 height: REAL,
919 graphics: *mut GpGraphics,
920 result: *mut BOOL,
921 ) -> GpStatus;
922}
923extern "C" {
924 #[link_name = "\u{1}GdipIsVisibleRegionRectI"]
925 pub fn GdipIsVisibleRegionRectI(
926 region: *mut GpRegion,
927 x: INT,
928 y: INT,
929 width: INT,
930 height: INT,
931 graphics: *mut GpGraphics,
932 result: *mut BOOL,
933 ) -> GpStatus;
934}
935extern "C" {
936 #[link_name = "\u{1}GdipGetRegionScansCount"]
937 pub fn GdipGetRegionScansCount(
938 region: *mut GpRegion,
939 count: *mut UINT,
940 matrix: *mut GpMatrix,
941 ) -> GpStatus;
942}
943extern "C" {
944 #[link_name = "\u{1}GdipGetRegionScans"]
945 pub fn GdipGetRegionScans(
946 region: *mut GpRegion,
947 rects: *mut GpRectF,
948 count: *mut INT,
949 matrix: *mut GpMatrix,
950 ) -> GpStatus;
951}
952extern "C" {
953 #[link_name = "\u{1}GdipGetRegionScansI"]
954 pub fn GdipGetRegionScansI(
955 region: *mut GpRegion,
956 rects: *mut GpRect,
957 count: *mut INT,
958 matrix: *mut GpMatrix,
959 ) -> GpStatus;
960}
961extern "C" {
962 #[link_name = "\u{1}GdipCloneBrush"]
963 pub fn GdipCloneBrush(brush: *mut GpBrush, cloneBrush: *mut *mut GpBrush) -> GpStatus;
964}
965extern "C" {
966 #[link_name = "\u{1}GdipDeleteBrush"]
967 pub fn GdipDeleteBrush(brush: *mut GpBrush) -> GpStatus;
968}
969extern "C" {
970 #[link_name = "\u{1}GdipGetBrushType"]
971 pub fn GdipGetBrushType(brush: *mut GpBrush, type_: *mut GpBrushType) -> GpStatus;
972}
973extern "C" {
974 #[link_name = "\u{1}GdipCreateHatchBrush"]
975 pub fn GdipCreateHatchBrush(
976 hatchstyle: GpHatchStyle,
977 forecol: ARGB,
978 backcol: ARGB,
979 brush: *mut *mut GpHatch,
980 ) -> GpStatus;
981}
982extern "C" {
983 #[link_name = "\u{1}GdipGetHatchStyle"]
984 pub fn GdipGetHatchStyle(brush: *mut GpHatch, hatchstyle: *mut GpHatchStyle) -> GpStatus;
985}
986extern "C" {
987 #[link_name = "\u{1}GdipGetHatchForegroundColor"]
988 pub fn GdipGetHatchForegroundColor(brush: *mut GpHatch, forecol: *mut ARGB) -> GpStatus;
989}
990extern "C" {
991 #[link_name = "\u{1}GdipGetHatchBackgroundColor"]
992 pub fn GdipGetHatchBackgroundColor(brush: *mut GpHatch, backcol: *mut ARGB) -> GpStatus;
993}
994extern "C" {
995 #[link_name = "\u{1}GdipCreateTexture"]
996 pub fn GdipCreateTexture(
997 image: *mut GpImage,
998 wrapmode: GpWrapMode,
999 texture: *mut *mut GpTexture,
1000 ) -> GpStatus;
1001}
1002extern "C" {
1003 #[link_name = "\u{1}GdipCreateTexture2"]
1004 pub fn GdipCreateTexture2(
1005 image: *mut GpImage,
1006 wrapmode: GpWrapMode,
1007 x: REAL,
1008 y: REAL,
1009 width: REAL,
1010 height: REAL,
1011 texture: *mut *mut GpTexture,
1012 ) -> GpStatus;
1013}
1014extern "C" {
1015 #[link_name = "\u{1}GdipCreateTextureIA"]
1016 pub fn GdipCreateTextureIA(
1017 image: *mut GpImage,
1018 imageAttributes: *const GpImageAttributes,
1019 x: REAL,
1020 y: REAL,
1021 width: REAL,
1022 height: REAL,
1023 texture: *mut *mut GpTexture,
1024 ) -> GpStatus;
1025}
1026extern "C" {
1027 #[link_name = "\u{1}GdipCreateTexture2I"]
1028 pub fn GdipCreateTexture2I(
1029 image: *mut GpImage,
1030 wrapmode: GpWrapMode,
1031 x: INT,
1032 y: INT,
1033 width: INT,
1034 height: INT,
1035 texture: *mut *mut GpTexture,
1036 ) -> GpStatus;
1037}
1038extern "C" {
1039 #[link_name = "\u{1}GdipCreateTextureIAI"]
1040 pub fn GdipCreateTextureIAI(
1041 image: *mut GpImage,
1042 imageAttributes: *const GpImageAttributes,
1043 x: INT,
1044 y: INT,
1045 width: INT,
1046 height: INT,
1047 texture: *mut *mut GpTexture,
1048 ) -> GpStatus;
1049}
1050extern "C" {
1051 #[link_name = "\u{1}GdipGetTextureTransform"]
1052 pub fn GdipGetTextureTransform(brush: *mut GpTexture, matrix: *mut GpMatrix) -> GpStatus;
1053}
1054extern "C" {
1055 #[link_name = "\u{1}GdipSetTextureTransform"]
1056 pub fn GdipSetTextureTransform(brush: *mut GpTexture, matrix: *const GpMatrix) -> GpStatus;
1057}
1058extern "C" {
1059 #[link_name = "\u{1}GdipResetTextureTransform"]
1060 pub fn GdipResetTextureTransform(brush: *mut GpTexture) -> GpStatus;
1061}
1062extern "C" {
1063 #[link_name = "\u{1}GdipMultiplyTextureTransform"]
1064 pub fn GdipMultiplyTextureTransform(
1065 brush: *mut GpTexture,
1066 matrix: *const GpMatrix,
1067 order: GpMatrixOrder,
1068 ) -> GpStatus;
1069}
1070extern "C" {
1071 #[link_name = "\u{1}GdipTranslateTextureTransform"]
1072 pub fn GdipTranslateTextureTransform(
1073 brush: *mut GpTexture,
1074 dx: REAL,
1075 dy: REAL,
1076 order: GpMatrixOrder,
1077 ) -> GpStatus;
1078}
1079extern "C" {
1080 #[link_name = "\u{1}GdipScaleTextureTransform"]
1081 pub fn GdipScaleTextureTransform(
1082 brush: *mut GpTexture,
1083 sx: REAL,
1084 sy: REAL,
1085 order: GpMatrixOrder,
1086 ) -> GpStatus;
1087}
1088extern "C" {
1089 #[link_name = "\u{1}GdipRotateTextureTransform"]
1090 pub fn GdipRotateTextureTransform(
1091 brush: *mut GpTexture,
1092 angle: REAL,
1093 order: GpMatrixOrder,
1094 ) -> GpStatus;
1095}
1096extern "C" {
1097 #[link_name = "\u{1}GdipSetTextureWrapMode"]
1098 pub fn GdipSetTextureWrapMode(brush: *mut GpTexture, wrapmode: GpWrapMode) -> GpStatus;
1099}
1100extern "C" {
1101 #[link_name = "\u{1}GdipGetTextureWrapMode"]
1102 pub fn GdipGetTextureWrapMode(brush: *mut GpTexture, wrapmode: *mut GpWrapMode) -> GpStatus;
1103}
1104extern "C" {
1105 #[link_name = "\u{1}GdipGetTextureImage"]
1106 pub fn GdipGetTextureImage(brush: *mut GpTexture, image: *mut *mut GpImage) -> GpStatus;
1107}
1108extern "C" {
1109 #[link_name = "\u{1}GdipCreateSolidFill"]
1110 pub fn GdipCreateSolidFill(color: ARGB, brush: *mut *mut GpSolidFill) -> GpStatus;
1111}
1112extern "C" {
1113 #[link_name = "\u{1}GdipSetSolidFillColor"]
1114 pub fn GdipSetSolidFillColor(brush: *mut GpSolidFill, color: ARGB) -> GpStatus;
1115}
1116extern "C" {
1117 #[link_name = "\u{1}GdipGetSolidFillColor"]
1118 pub fn GdipGetSolidFillColor(brush: *mut GpSolidFill, color: *mut ARGB) -> GpStatus;
1119}
1120extern "C" {
1121 #[link_name = "\u{1}GdipCreateLineBrush"]
1122 pub fn GdipCreateLineBrush(
1123 point1: *const GpPointF,
1124 point2: *const GpPointF,
1125 color1: ARGB,
1126 color2: ARGB,
1127 wrapMode: GpWrapMode,
1128 lineGradient: *mut *mut GpLineGradient,
1129 ) -> GpStatus;
1130}
1131extern "C" {
1132 #[link_name = "\u{1}GdipCreateLineBrushI"]
1133 pub fn GdipCreateLineBrushI(
1134 point1: *const GpPoint,
1135 point2: *const GpPoint,
1136 color1: ARGB,
1137 color2: ARGB,
1138 wrapMode: GpWrapMode,
1139 lineGradient: *mut *mut GpLineGradient,
1140 ) -> GpStatus;
1141}
1142extern "C" {
1143 #[link_name = "\u{1}GdipCreateLineBrushFromRect"]
1144 pub fn GdipCreateLineBrushFromRect(
1145 rect: *const GpRectF,
1146 color1: ARGB,
1147 color2: ARGB,
1148 mode: LinearGradientMode,
1149 wrapMode: GpWrapMode,
1150 lineGradient: *mut *mut GpLineGradient,
1151 ) -> GpStatus;
1152}
1153extern "C" {
1154 #[link_name = "\u{1}GdipCreateLineBrushFromRectI"]
1155 pub fn GdipCreateLineBrushFromRectI(
1156 rect: *const GpRect,
1157 color1: ARGB,
1158 color2: ARGB,
1159 mode: LinearGradientMode,
1160 wrapMode: GpWrapMode,
1161 lineGradient: *mut *mut GpLineGradient,
1162 ) -> GpStatus;
1163}
1164extern "C" {
1165 #[link_name = "\u{1}GdipCreateLineBrushFromRectWithAngle"]
1166 pub fn GdipCreateLineBrushFromRectWithAngle(
1167 rect: *const GpRectF,
1168 color1: ARGB,
1169 color2: ARGB,
1170 angle: REAL,
1171 isAngleScalable: BOOL,
1172 wrapMode: GpWrapMode,
1173 lineGradient: *mut *mut GpLineGradient,
1174 ) -> GpStatus;
1175}
1176extern "C" {
1177 #[link_name = "\u{1}GdipCreateLineBrushFromRectWithAngleI"]
1178 pub fn GdipCreateLineBrushFromRectWithAngleI(
1179 rect: *const GpRect,
1180 color1: ARGB,
1181 color2: ARGB,
1182 angle: REAL,
1183 isAngleScalable: BOOL,
1184 wrapMode: GpWrapMode,
1185 lineGradient: *mut *mut GpLineGradient,
1186 ) -> GpStatus;
1187}
1188extern "C" {
1189 #[link_name = "\u{1}GdipSetLineColors"]
1190 pub fn GdipSetLineColors(brush: *mut GpLineGradient, color1: ARGB, color2: ARGB) -> GpStatus;
1191}
1192extern "C" {
1193 #[link_name = "\u{1}GdipGetLineColors"]
1194 pub fn GdipGetLineColors(brush: *mut GpLineGradient, colors: *mut ARGB) -> GpStatus;
1195}
1196extern "C" {
1197 #[link_name = "\u{1}GdipGetLineRect"]
1198 pub fn GdipGetLineRect(brush: *mut GpLineGradient, rect: *mut GpRectF) -> GpStatus;
1199}
1200extern "C" {
1201 #[link_name = "\u{1}GdipGetLineRectI"]
1202 pub fn GdipGetLineRectI(brush: *mut GpLineGradient, rect: *mut GpRect) -> GpStatus;
1203}
1204extern "C" {
1205 #[link_name = "\u{1}GdipSetLineGammaCorrection"]
1206 pub fn GdipSetLineGammaCorrection(
1207 brush: *mut GpLineGradient,
1208 useGammaCorrection: BOOL,
1209 ) -> GpStatus;
1210}
1211extern "C" {
1212 #[link_name = "\u{1}GdipGetLineGammaCorrection"]
1213 pub fn GdipGetLineGammaCorrection(
1214 brush: *mut GpLineGradient,
1215 useGammaCorrection: *mut BOOL,
1216 ) -> GpStatus;
1217}
1218extern "C" {
1219 #[link_name = "\u{1}GdipGetLineBlendCount"]
1220 pub fn GdipGetLineBlendCount(brush: *mut GpLineGradient, count: *mut INT) -> GpStatus;
1221}
1222extern "C" {
1223 #[link_name = "\u{1}GdipGetLineBlend"]
1224 pub fn GdipGetLineBlend(
1225 brush: *mut GpLineGradient,
1226 blend: *mut REAL,
1227 positions: *mut REAL,
1228 count: INT,
1229 ) -> GpStatus;
1230}
1231extern "C" {
1232 #[link_name = "\u{1}GdipSetLineBlend"]
1233 pub fn GdipSetLineBlend(
1234 brush: *mut GpLineGradient,
1235 blend: *const REAL,
1236 positions: *const REAL,
1237 count: INT,
1238 ) -> GpStatus;
1239}
1240extern "C" {
1241 #[link_name = "\u{1}GdipGetLinePresetBlendCount"]
1242 pub fn GdipGetLinePresetBlendCount(brush: *mut GpLineGradient, count: *mut INT) -> GpStatus;
1243}
1244extern "C" {
1245 #[link_name = "\u{1}GdipGetLinePresetBlend"]
1246 pub fn GdipGetLinePresetBlend(
1247 brush: *mut GpLineGradient,
1248 blend: *mut ARGB,
1249 positions: *mut REAL,
1250 count: INT,
1251 ) -> GpStatus;
1252}
1253extern "C" {
1254 #[link_name = "\u{1}GdipSetLinePresetBlend"]
1255 pub fn GdipSetLinePresetBlend(
1256 brush: *mut GpLineGradient,
1257 blend: *const ARGB,
1258 positions: *const REAL,
1259 count: INT,
1260 ) -> GpStatus;
1261}
1262extern "C" {
1263 #[link_name = "\u{1}GdipSetLineSigmaBlend"]
1264 pub fn GdipSetLineSigmaBlend(brush: *mut GpLineGradient, focus: REAL, scale: REAL) -> GpStatus;
1265}
1266extern "C" {
1267 #[link_name = "\u{1}GdipSetLineLinearBlend"]
1268 pub fn GdipSetLineLinearBlend(brush: *mut GpLineGradient, focus: REAL, scale: REAL)
1269 -> GpStatus;
1270}
1271extern "C" {
1272 #[link_name = "\u{1}GdipSetLineWrapMode"]
1273 pub fn GdipSetLineWrapMode(brush: *mut GpLineGradient, wrapmode: GpWrapMode) -> GpStatus;
1274}
1275extern "C" {
1276 #[link_name = "\u{1}GdipGetLineWrapMode"]
1277 pub fn GdipGetLineWrapMode(brush: *mut GpLineGradient, wrapmode: *mut GpWrapMode) -> GpStatus;
1278}
1279extern "C" {
1280 #[link_name = "\u{1}GdipGetLineTransform"]
1281 pub fn GdipGetLineTransform(brush: *mut GpLineGradient, matrix: *mut GpMatrix) -> GpStatus;
1282}
1283extern "C" {
1284 #[link_name = "\u{1}GdipSetLineTransform"]
1285 pub fn GdipSetLineTransform(brush: *mut GpLineGradient, matrix: *const GpMatrix) -> GpStatus;
1286}
1287extern "C" {
1288 #[link_name = "\u{1}GdipResetLineTransform"]
1289 pub fn GdipResetLineTransform(brush: *mut GpLineGradient) -> GpStatus;
1290}
1291extern "C" {
1292 #[link_name = "\u{1}GdipMultiplyLineTransform"]
1293 pub fn GdipMultiplyLineTransform(
1294 brush: *mut GpLineGradient,
1295 matrix: *const GpMatrix,
1296 order: GpMatrixOrder,
1297 ) -> GpStatus;
1298}
1299extern "C" {
1300 #[link_name = "\u{1}GdipTranslateLineTransform"]
1301 pub fn GdipTranslateLineTransform(
1302 brush: *mut GpLineGradient,
1303 dx: REAL,
1304 dy: REAL,
1305 order: GpMatrixOrder,
1306 ) -> GpStatus;
1307}
1308extern "C" {
1309 #[link_name = "\u{1}GdipScaleLineTransform"]
1310 pub fn GdipScaleLineTransform(
1311 brush: *mut GpLineGradient,
1312 sx: REAL,
1313 sy: REAL,
1314 order: GpMatrixOrder,
1315 ) -> GpStatus;
1316}
1317extern "C" {
1318 #[link_name = "\u{1}GdipRotateLineTransform"]
1319 pub fn GdipRotateLineTransform(
1320 brush: *mut GpLineGradient,
1321 angle: REAL,
1322 order: GpMatrixOrder,
1323 ) -> GpStatus;
1324}
1325extern "C" {
1326 #[link_name = "\u{1}GdipCreatePathGradient"]
1327 pub fn GdipCreatePathGradient(
1328 points: *const GpPointF,
1329 count: INT,
1330 wrapMode: GpWrapMode,
1331 polyGradient: *mut *mut GpPathGradient,
1332 ) -> GpStatus;
1333}
1334extern "C" {
1335 #[link_name = "\u{1}GdipCreatePathGradientI"]
1336 pub fn GdipCreatePathGradientI(
1337 points: *const GpPoint,
1338 count: INT,
1339 wrapMode: GpWrapMode,
1340 polyGradient: *mut *mut GpPathGradient,
1341 ) -> GpStatus;
1342}
1343extern "C" {
1344 #[link_name = "\u{1}GdipCreatePathGradientFromPath"]
1345 pub fn GdipCreatePathGradientFromPath(
1346 path: *const GpPath,
1347 polyGradient: *mut *mut GpPathGradient,
1348 ) -> GpStatus;
1349}
1350extern "C" {
1351 #[link_name = "\u{1}GdipGetPathGradientCenterColor"]
1352 pub fn GdipGetPathGradientCenterColor(
1353 brush: *mut GpPathGradient,
1354 colors: *mut ARGB,
1355 ) -> GpStatus;
1356}
1357extern "C" {
1358 #[link_name = "\u{1}GdipSetPathGradientCenterColor"]
1359 pub fn GdipSetPathGradientCenterColor(brush: *mut GpPathGradient, colors: ARGB) -> GpStatus;
1360}
1361extern "C" {
1362 #[link_name = "\u{1}GdipGetPathGradientSurroundColorsWithCount"]
1363 pub fn GdipGetPathGradientSurroundColorsWithCount(
1364 brush: *mut GpPathGradient,
1365 color: *mut ARGB,
1366 count: *mut INT,
1367 ) -> GpStatus;
1368}
1369extern "C" {
1370 #[link_name = "\u{1}GdipSetPathGradientSurroundColorsWithCount"]
1371 pub fn GdipSetPathGradientSurroundColorsWithCount(
1372 brush: *mut GpPathGradient,
1373 color: *const ARGB,
1374 count: *mut INT,
1375 ) -> GpStatus;
1376}
1377extern "C" {
1378 #[link_name = "\u{1}GdipGetPathGradientPath"]
1379 pub fn GdipGetPathGradientPath(brush: *mut GpPathGradient, path: *mut GpPath) -> GpStatus;
1380}
1381extern "C" {
1382 #[link_name = "\u{1}GdipSetPathGradientPath"]
1383 pub fn GdipSetPathGradientPath(brush: *mut GpPathGradient, path: *const GpPath) -> GpStatus;
1384}
1385extern "C" {
1386 #[link_name = "\u{1}GdipGetPathGradientCenterPoint"]
1387 pub fn GdipGetPathGradientCenterPoint(
1388 brush: *mut GpPathGradient,
1389 points: *mut GpPointF,
1390 ) -> GpStatus;
1391}
1392extern "C" {
1393 #[link_name = "\u{1}GdipGetPathGradientCenterPointI"]
1394 pub fn GdipGetPathGradientCenterPointI(
1395 brush: *mut GpPathGradient,
1396 points: *mut GpPoint,
1397 ) -> GpStatus;
1398}
1399extern "C" {
1400 #[link_name = "\u{1}GdipSetPathGradientCenterPoint"]
1401 pub fn GdipSetPathGradientCenterPoint(
1402 brush: *mut GpPathGradient,
1403 points: *const GpPointF,
1404 ) -> GpStatus;
1405}
1406extern "C" {
1407 #[link_name = "\u{1}GdipSetPathGradientCenterPointI"]
1408 pub fn GdipSetPathGradientCenterPointI(
1409 brush: *mut GpPathGradient,
1410 points: *const GpPoint,
1411 ) -> GpStatus;
1412}
1413extern "C" {
1414 #[link_name = "\u{1}GdipGetPathGradientRect"]
1415 pub fn GdipGetPathGradientRect(brush: *mut GpPathGradient, rect: *mut GpRectF) -> GpStatus;
1416}
1417extern "C" {
1418 #[link_name = "\u{1}GdipGetPathGradientRectI"]
1419 pub fn GdipGetPathGradientRectI(brush: *mut GpPathGradient, rect: *mut GpRect) -> GpStatus;
1420}
1421extern "C" {
1422 #[link_name = "\u{1}GdipGetPathGradientPointCount"]
1423 pub fn GdipGetPathGradientPointCount(brush: *mut GpPathGradient, count: *mut INT) -> GpStatus;
1424}
1425extern "C" {
1426 #[link_name = "\u{1}GdipGetPathGradientSurroundColorCount"]
1427 pub fn GdipGetPathGradientSurroundColorCount(
1428 brush: *mut GpPathGradient,
1429 count: *mut INT,
1430 ) -> GpStatus;
1431}
1432extern "C" {
1433 #[link_name = "\u{1}GdipSetPathGradientGammaCorrection"]
1434 pub fn GdipSetPathGradientGammaCorrection(
1435 brush: *mut GpPathGradient,
1436 useGammaCorrection: BOOL,
1437 ) -> GpStatus;
1438}
1439extern "C" {
1440 #[link_name = "\u{1}GdipGetPathGradientGammaCorrection"]
1441 pub fn GdipGetPathGradientGammaCorrection(
1442 brush: *mut GpPathGradient,
1443 useGammaCorrection: *mut BOOL,
1444 ) -> GpStatus;
1445}
1446extern "C" {
1447 #[link_name = "\u{1}GdipGetPathGradientBlendCount"]
1448 pub fn GdipGetPathGradientBlendCount(brush: *mut GpPathGradient, count: *mut INT) -> GpStatus;
1449}
1450extern "C" {
1451 #[link_name = "\u{1}GdipGetPathGradientBlend"]
1452 pub fn GdipGetPathGradientBlend(
1453 brush: *mut GpPathGradient,
1454 blend: *mut REAL,
1455 positions: *mut REAL,
1456 count: INT,
1457 ) -> GpStatus;
1458}
1459extern "C" {
1460 #[link_name = "\u{1}GdipSetPathGradientBlend"]
1461 pub fn GdipSetPathGradientBlend(
1462 brush: *mut GpPathGradient,
1463 blend: *const REAL,
1464 positions: *const REAL,
1465 count: INT,
1466 ) -> GpStatus;
1467}
1468extern "C" {
1469 #[link_name = "\u{1}GdipGetPathGradientPresetBlendCount"]
1470 pub fn GdipGetPathGradientPresetBlendCount(
1471 brush: *mut GpPathGradient,
1472 count: *mut INT,
1473 ) -> GpStatus;
1474}
1475extern "C" {
1476 #[link_name = "\u{1}GdipGetPathGradientPresetBlend"]
1477 pub fn GdipGetPathGradientPresetBlend(
1478 brush: *mut GpPathGradient,
1479 blend: *mut ARGB,
1480 positions: *mut REAL,
1481 count: INT,
1482 ) -> GpStatus;
1483}
1484extern "C" {
1485 #[link_name = "\u{1}GdipSetPathGradientPresetBlend"]
1486 pub fn GdipSetPathGradientPresetBlend(
1487 brush: *mut GpPathGradient,
1488 blend: *const ARGB,
1489 positions: *const REAL,
1490 count: INT,
1491 ) -> GpStatus;
1492}
1493extern "C" {
1494 #[link_name = "\u{1}GdipSetPathGradientSigmaBlend"]
1495 pub fn GdipSetPathGradientSigmaBlend(
1496 brush: *mut GpPathGradient,
1497 focus: REAL,
1498 scale: REAL,
1499 ) -> GpStatus;
1500}
1501extern "C" {
1502 #[link_name = "\u{1}GdipSetPathGradientLinearBlend"]
1503 pub fn GdipSetPathGradientLinearBlend(
1504 brush: *mut GpPathGradient,
1505 focus: REAL,
1506 scale: REAL,
1507 ) -> GpStatus;
1508}
1509extern "C" {
1510 #[link_name = "\u{1}GdipGetPathGradientWrapMode"]
1511 pub fn GdipGetPathGradientWrapMode(
1512 brush: *mut GpPathGradient,
1513 wrapmode: *mut GpWrapMode,
1514 ) -> GpStatus;
1515}
1516extern "C" {
1517 #[link_name = "\u{1}GdipSetPathGradientWrapMode"]
1518 pub fn GdipSetPathGradientWrapMode(
1519 brush: *mut GpPathGradient,
1520 wrapmode: GpWrapMode,
1521 ) -> GpStatus;
1522}
1523extern "C" {
1524 #[link_name = "\u{1}GdipGetPathGradientTransform"]
1525 pub fn GdipGetPathGradientTransform(
1526 brush: *mut GpPathGradient,
1527 matrix: *mut GpMatrix,
1528 ) -> GpStatus;
1529}
1530extern "C" {
1531 #[link_name = "\u{1}GdipSetPathGradientTransform"]
1532 pub fn GdipSetPathGradientTransform(
1533 brush: *mut GpPathGradient,
1534 matrix: *mut GpMatrix,
1535 ) -> GpStatus;
1536}
1537extern "C" {
1538 #[link_name = "\u{1}GdipResetPathGradientTransform"]
1539 pub fn GdipResetPathGradientTransform(brush: *mut GpPathGradient) -> GpStatus;
1540}
1541extern "C" {
1542 #[link_name = "\u{1}GdipMultiplyPathGradientTransform"]
1543 pub fn GdipMultiplyPathGradientTransform(
1544 brush: *mut GpPathGradient,
1545 matrix: *const GpMatrix,
1546 order: GpMatrixOrder,
1547 ) -> GpStatus;
1548}
1549extern "C" {
1550 #[link_name = "\u{1}GdipTranslatePathGradientTransform"]
1551 pub fn GdipTranslatePathGradientTransform(
1552 brush: *mut GpPathGradient,
1553 dx: REAL,
1554 dy: REAL,
1555 order: GpMatrixOrder,
1556 ) -> GpStatus;
1557}
1558extern "C" {
1559 #[link_name = "\u{1}GdipScalePathGradientTransform"]
1560 pub fn GdipScalePathGradientTransform(
1561 brush: *mut GpPathGradient,
1562 sx: REAL,
1563 sy: REAL,
1564 order: GpMatrixOrder,
1565 ) -> GpStatus;
1566}
1567extern "C" {
1568 #[link_name = "\u{1}GdipRotatePathGradientTransform"]
1569 pub fn GdipRotatePathGradientTransform(
1570 brush: *mut GpPathGradient,
1571 angle: REAL,
1572 order: GpMatrixOrder,
1573 ) -> GpStatus;
1574}
1575extern "C" {
1576 #[link_name = "\u{1}GdipGetPathGradientFocusScales"]
1577 pub fn GdipGetPathGradientFocusScales(
1578 brush: *mut GpPathGradient,
1579 xScale: *mut REAL,
1580 yScale: *mut REAL,
1581 ) -> GpStatus;
1582}
1583extern "C" {
1584 #[link_name = "\u{1}GdipSetPathGradientFocusScales"]
1585 pub fn GdipSetPathGradientFocusScales(
1586 brush: *mut GpPathGradient,
1587 xScale: REAL,
1588 yScale: REAL,
1589 ) -> GpStatus;
1590}
1591extern "C" {
1592 #[link_name = "\u{1}GdipCreatePen1"]
1593 pub fn GdipCreatePen1(color: ARGB, width: REAL, unit: GpUnit, pen: *mut *mut GpPen)
1594 -> GpStatus;
1595}
1596extern "C" {
1597 #[link_name = "\u{1}GdipCreatePen2"]
1598 pub fn GdipCreatePen2(
1599 brush: *mut GpBrush,
1600 width: REAL,
1601 unit: GpUnit,
1602 pen: *mut *mut GpPen,
1603 ) -> GpStatus;
1604}
1605extern "C" {
1606 #[link_name = "\u{1}GdipClonePen"]
1607 pub fn GdipClonePen(pen: *mut GpPen, clonepen: *mut *mut GpPen) -> GpStatus;
1608}
1609extern "C" {
1610 #[link_name = "\u{1}GdipDeletePen"]
1611 pub fn GdipDeletePen(pen: *mut GpPen) -> GpStatus;
1612}
1613extern "C" {
1614 #[link_name = "\u{1}GdipSetPenWidth"]
1615 pub fn GdipSetPenWidth(pen: *mut GpPen, width: REAL) -> GpStatus;
1616}
1617extern "C" {
1618 #[link_name = "\u{1}GdipGetPenWidth"]
1619 pub fn GdipGetPenWidth(pen: *mut GpPen, width: *mut REAL) -> GpStatus;
1620}
1621extern "C" {
1622 #[link_name = "\u{1}GdipSetPenUnit"]
1623 pub fn GdipSetPenUnit(pen: *mut GpPen, unit: GpUnit) -> GpStatus;
1624}
1625extern "C" {
1626 #[link_name = "\u{1}GdipGetPenUnit"]
1627 pub fn GdipGetPenUnit(pen: *mut GpPen, unit: *mut GpUnit) -> GpStatus;
1628}
1629extern "C" {
1630 #[link_name = "\u{1}GdipSetPenLineCap197819"]
1631 pub fn GdipSetPenLineCap197819(
1632 pen: *mut GpPen,
1633 startCap: GpLineCap,
1634 endCap: GpLineCap,
1635 dashCap: GpDashCap,
1636 ) -> GpStatus;
1637}
1638extern "C" {
1639 #[link_name = "\u{1}GdipSetPenStartCap"]
1640 pub fn GdipSetPenStartCap(pen: *mut GpPen, startCap: GpLineCap) -> GpStatus;
1641}
1642extern "C" {
1643 #[link_name = "\u{1}GdipSetPenEndCap"]
1644 pub fn GdipSetPenEndCap(pen: *mut GpPen, endCap: GpLineCap) -> GpStatus;
1645}
1646extern "C" {
1647 #[link_name = "\u{1}GdipSetPenDashCap197819"]
1648 pub fn GdipSetPenDashCap197819(pen: *mut GpPen, dashCap: GpDashCap) -> GpStatus;
1649}
1650extern "C" {
1651 #[link_name = "\u{1}GdipGetPenStartCap"]
1652 pub fn GdipGetPenStartCap(pen: *mut GpPen, startCap: *mut GpLineCap) -> GpStatus;
1653}
1654extern "C" {
1655 #[link_name = "\u{1}GdipGetPenEndCap"]
1656 pub fn GdipGetPenEndCap(pen: *mut GpPen, endCap: *mut GpLineCap) -> GpStatus;
1657}
1658extern "C" {
1659 #[link_name = "\u{1}GdipGetPenDashCap197819"]
1660 pub fn GdipGetPenDashCap197819(pen: *mut GpPen, dashCap: *mut GpDashCap) -> GpStatus;
1661}
1662extern "C" {
1663 #[link_name = "\u{1}GdipSetPenLineJoin"]
1664 pub fn GdipSetPenLineJoin(pen: *mut GpPen, lineJoin: GpLineJoin) -> GpStatus;
1665}
1666extern "C" {
1667 #[link_name = "\u{1}GdipGetPenLineJoin"]
1668 pub fn GdipGetPenLineJoin(pen: *mut GpPen, lineJoin: *mut GpLineJoin) -> GpStatus;
1669}
1670extern "C" {
1671 #[link_name = "\u{1}GdipSetPenCustomStartCap"]
1672 pub fn GdipSetPenCustomStartCap(pen: *mut GpPen, customCap: *mut GpCustomLineCap) -> GpStatus;
1673}
1674extern "C" {
1675 #[link_name = "\u{1}GdipGetPenCustomStartCap"]
1676 pub fn GdipGetPenCustomStartCap(
1677 pen: *mut GpPen,
1678 customCap: *mut *mut GpCustomLineCap,
1679 ) -> GpStatus;
1680}
1681extern "C" {
1682 #[link_name = "\u{1}GdipSetPenCustomEndCap"]
1683 pub fn GdipSetPenCustomEndCap(pen: *mut GpPen, customCap: *mut GpCustomLineCap) -> GpStatus;
1684}
1685extern "C" {
1686 #[link_name = "\u{1}GdipGetPenCustomEndCap"]
1687 pub fn GdipGetPenCustomEndCap(
1688 pen: *mut GpPen,
1689 customCap: *mut *mut GpCustomLineCap,
1690 ) -> GpStatus;
1691}
1692extern "C" {
1693 #[link_name = "\u{1}GdipSetPenMiterLimit"]
1694 pub fn GdipSetPenMiterLimit(pen: *mut GpPen, miterLimit: REAL) -> GpStatus;
1695}
1696extern "C" {
1697 #[link_name = "\u{1}GdipGetPenMiterLimit"]
1698 pub fn GdipGetPenMiterLimit(pen: *mut GpPen, miterLimit: *mut REAL) -> GpStatus;
1699}
1700extern "C" {
1701 #[link_name = "\u{1}GdipSetPenMode"]
1702 pub fn GdipSetPenMode(pen: *mut GpPen, penMode: GpPenAlignment) -> GpStatus;
1703}
1704extern "C" {
1705 #[link_name = "\u{1}GdipGetPenMode"]
1706 pub fn GdipGetPenMode(pen: *mut GpPen, penMode: *mut GpPenAlignment) -> GpStatus;
1707}
1708extern "C" {
1709 #[link_name = "\u{1}GdipSetPenTransform"]
1710 pub fn GdipSetPenTransform(pen: *mut GpPen, matrix: *mut GpMatrix) -> GpStatus;
1711}
1712extern "C" {
1713 #[link_name = "\u{1}GdipGetPenTransform"]
1714 pub fn GdipGetPenTransform(pen: *mut GpPen, matrix: *mut GpMatrix) -> GpStatus;
1715}
1716extern "C" {
1717 #[link_name = "\u{1}GdipResetPenTransform"]
1718 pub fn GdipResetPenTransform(pen: *mut GpPen) -> GpStatus;
1719}
1720extern "C" {
1721 #[link_name = "\u{1}GdipMultiplyPenTransform"]
1722 pub fn GdipMultiplyPenTransform(
1723 pen: *mut GpPen,
1724 matrix: *const GpMatrix,
1725 order: GpMatrixOrder,
1726 ) -> GpStatus;
1727}
1728extern "C" {
1729 #[link_name = "\u{1}GdipTranslatePenTransform"]
1730 pub fn GdipTranslatePenTransform(
1731 pen: *mut GpPen,
1732 dx: REAL,
1733 dy: REAL,
1734 order: GpMatrixOrder,
1735 ) -> GpStatus;
1736}
1737extern "C" {
1738 #[link_name = "\u{1}GdipScalePenTransform"]
1739 pub fn GdipScalePenTransform(
1740 pen: *mut GpPen,
1741 sx: REAL,
1742 sy: REAL,
1743 order: GpMatrixOrder,
1744 ) -> GpStatus;
1745}
1746extern "C" {
1747 #[link_name = "\u{1}GdipRotatePenTransform"]
1748 pub fn GdipRotatePenTransform(pen: *mut GpPen, angle: REAL, order: GpMatrixOrder) -> GpStatus;
1749}
1750extern "C" {
1751 #[link_name = "\u{1}GdipSetPenColor"]
1752 pub fn GdipSetPenColor(pen: *mut GpPen, argb: ARGB) -> GpStatus;
1753}
1754extern "C" {
1755 #[link_name = "\u{1}GdipGetPenColor"]
1756 pub fn GdipGetPenColor(pen: *mut GpPen, argb: *mut ARGB) -> GpStatus;
1757}
1758extern "C" {
1759 #[link_name = "\u{1}GdipSetPenBrushFill"]
1760 pub fn GdipSetPenBrushFill(pen: *mut GpPen, brush: *mut GpBrush) -> GpStatus;
1761}
1762extern "C" {
1763 #[link_name = "\u{1}GdipGetPenBrushFill"]
1764 pub fn GdipGetPenBrushFill(pen: *mut GpPen, brush: *mut *mut GpBrush) -> GpStatus;
1765}
1766extern "C" {
1767 #[link_name = "\u{1}GdipGetPenFillType"]
1768 pub fn GdipGetPenFillType(pen: *mut GpPen, type_: *mut GpPenType) -> GpStatus;
1769}
1770extern "C" {
1771 #[link_name = "\u{1}GdipGetPenDashStyle"]
1772 pub fn GdipGetPenDashStyle(pen: *mut GpPen, dashstyle: *mut GpDashStyle) -> GpStatus;
1773}
1774extern "C" {
1775 #[link_name = "\u{1}GdipSetPenDashStyle"]
1776 pub fn GdipSetPenDashStyle(pen: *mut GpPen, dashstyle: GpDashStyle) -> GpStatus;
1777}
1778extern "C" {
1779 #[link_name = "\u{1}GdipGetPenDashOffset"]
1780 pub fn GdipGetPenDashOffset(pen: *mut GpPen, offset: *mut REAL) -> GpStatus;
1781}
1782extern "C" {
1783 #[link_name = "\u{1}GdipSetPenDashOffset"]
1784 pub fn GdipSetPenDashOffset(pen: *mut GpPen, offset: REAL) -> GpStatus;
1785}
1786extern "C" {
1787 #[link_name = "\u{1}GdipGetPenDashCount"]
1788 pub fn GdipGetPenDashCount(pen: *mut GpPen, count: *mut INT) -> GpStatus;
1789}
1790extern "C" {
1791 #[link_name = "\u{1}GdipSetPenDashArray"]
1792 pub fn GdipSetPenDashArray(pen: *mut GpPen, dash: *const REAL, count: INT) -> GpStatus;
1793}
1794extern "C" {
1795 #[link_name = "\u{1}GdipGetPenDashArray"]
1796 pub fn GdipGetPenDashArray(pen: *mut GpPen, dash: *mut REAL, count: INT) -> GpStatus;
1797}
1798extern "C" {
1799 #[link_name = "\u{1}GdipGetPenCompoundCount"]
1800 pub fn GdipGetPenCompoundCount(pen: *mut GpPen, count: *mut INT) -> GpStatus;
1801}
1802extern "C" {
1803 #[link_name = "\u{1}GdipSetPenCompoundArray"]
1804 pub fn GdipSetPenCompoundArray(pen: *mut GpPen, dash: *const REAL, count: INT) -> GpStatus;
1805}
1806extern "C" {
1807 #[link_name = "\u{1}GdipGetPenCompoundArray"]
1808 pub fn GdipGetPenCompoundArray(pen: *mut GpPen, dash: *mut REAL, count: INT) -> GpStatus;
1809}
1810extern "C" {
1811 #[link_name = "\u{1}GdipCreateCustomLineCap"]
1812 pub fn GdipCreateCustomLineCap(
1813 fillPath: *mut GpPath,
1814 strokePath: *mut GpPath,
1815 baseCap: GpLineCap,
1816 baseInset: REAL,
1817 customCap: *mut *mut GpCustomLineCap,
1818 ) -> GpStatus;
1819}
1820extern "C" {
1821 #[link_name = "\u{1}GdipDeleteCustomLineCap"]
1822 pub fn GdipDeleteCustomLineCap(customCap: *mut GpCustomLineCap) -> GpStatus;
1823}
1824extern "C" {
1825 #[link_name = "\u{1}GdipCloneCustomLineCap"]
1826 pub fn GdipCloneCustomLineCap(
1827 customCap: *mut GpCustomLineCap,
1828 clonedCap: *mut *mut GpCustomLineCap,
1829 ) -> GpStatus;
1830}
1831extern "C" {
1832 #[link_name = "\u{1}GdipGetCustomLineCapType"]
1833 pub fn GdipGetCustomLineCapType(
1834 customCap: *mut GpCustomLineCap,
1835 capType: *mut CustomLineCapType,
1836 ) -> GpStatus;
1837}
1838extern "C" {
1839 #[link_name = "\u{1}GdipSetCustomLineCapStrokeCaps"]
1840 pub fn GdipSetCustomLineCapStrokeCaps(
1841 customCap: *mut GpCustomLineCap,
1842 startCap: GpLineCap,
1843 endCap: GpLineCap,
1844 ) -> GpStatus;
1845}
1846extern "C" {
1847 #[link_name = "\u{1}GdipGetCustomLineCapStrokeCaps"]
1848 pub fn GdipGetCustomLineCapStrokeCaps(
1849 customCap: *mut GpCustomLineCap,
1850 startCap: *mut GpLineCap,
1851 endCap: *mut GpLineCap,
1852 ) -> GpStatus;
1853}
1854extern "C" {
1855 #[link_name = "\u{1}GdipSetCustomLineCapStrokeJoin"]
1856 pub fn GdipSetCustomLineCapStrokeJoin(
1857 customCap: *mut GpCustomLineCap,
1858 lineJoin: GpLineJoin,
1859 ) -> GpStatus;
1860}
1861extern "C" {
1862 #[link_name = "\u{1}GdipGetCustomLineCapStrokeJoin"]
1863 pub fn GdipGetCustomLineCapStrokeJoin(
1864 customCap: *mut GpCustomLineCap,
1865 lineJoin: *mut GpLineJoin,
1866 ) -> GpStatus;
1867}
1868extern "C" {
1869 #[link_name = "\u{1}GdipSetCustomLineCapBaseCap"]
1870 pub fn GdipSetCustomLineCapBaseCap(
1871 customCap: *mut GpCustomLineCap,
1872 baseCap: GpLineCap,
1873 ) -> GpStatus;
1874}
1875extern "C" {
1876 #[link_name = "\u{1}GdipGetCustomLineCapBaseCap"]
1877 pub fn GdipGetCustomLineCapBaseCap(
1878 customCap: *mut GpCustomLineCap,
1879 baseCap: *mut GpLineCap,
1880 ) -> GpStatus;
1881}
1882extern "C" {
1883 #[link_name = "\u{1}GdipSetCustomLineCapBaseInset"]
1884 pub fn GdipSetCustomLineCapBaseInset(customCap: *mut GpCustomLineCap, inset: REAL) -> GpStatus;
1885}
1886extern "C" {
1887 #[link_name = "\u{1}GdipGetCustomLineCapBaseInset"]
1888 pub fn GdipGetCustomLineCapBaseInset(
1889 customCap: *mut GpCustomLineCap,
1890 inset: *mut REAL,
1891 ) -> GpStatus;
1892}
1893extern "C" {
1894 #[link_name = "\u{1}GdipSetCustomLineCapWidthScale"]
1895 pub fn GdipSetCustomLineCapWidthScale(
1896 customCap: *mut GpCustomLineCap,
1897 widthScale: REAL,
1898 ) -> GpStatus;
1899}
1900extern "C" {
1901 #[link_name = "\u{1}GdipGetCustomLineCapWidthScale"]
1902 pub fn GdipGetCustomLineCapWidthScale(
1903 customCap: *mut GpCustomLineCap,
1904 widthScale: *mut REAL,
1905 ) -> GpStatus;
1906}
1907extern "C" {
1908 #[link_name = "\u{1}GdipCreateAdjustableArrowCap"]
1909 pub fn GdipCreateAdjustableArrowCap(
1910 height: REAL,
1911 width: REAL,
1912 isFilled: BOOL,
1913 cap: *mut *mut GpAdjustableArrowCap,
1914 ) -> GpStatus;
1915}
1916extern "C" {
1917 #[link_name = "\u{1}GdipSetAdjustableArrowCapHeight"]
1918 pub fn GdipSetAdjustableArrowCapHeight(
1919 cap: *mut GpAdjustableArrowCap,
1920 height: REAL,
1921 ) -> GpStatus;
1922}
1923extern "C" {
1924 #[link_name = "\u{1}GdipGetAdjustableArrowCapHeight"]
1925 pub fn GdipGetAdjustableArrowCapHeight(
1926 cap: *mut GpAdjustableArrowCap,
1927 height: *mut REAL,
1928 ) -> GpStatus;
1929}
1930extern "C" {
1931 #[link_name = "\u{1}GdipSetAdjustableArrowCapWidth"]
1932 pub fn GdipSetAdjustableArrowCapWidth(cap: *mut GpAdjustableArrowCap, width: REAL) -> GpStatus;
1933}
1934extern "C" {
1935 #[link_name = "\u{1}GdipGetAdjustableArrowCapWidth"]
1936 pub fn GdipGetAdjustableArrowCapWidth(
1937 cap: *mut GpAdjustableArrowCap,
1938 width: *mut REAL,
1939 ) -> GpStatus;
1940}
1941extern "C" {
1942 #[link_name = "\u{1}GdipSetAdjustableArrowCapMiddleInset"]
1943 pub fn GdipSetAdjustableArrowCapMiddleInset(
1944 cap: *mut GpAdjustableArrowCap,
1945 middleInset: REAL,
1946 ) -> GpStatus;
1947}
1948extern "C" {
1949 #[link_name = "\u{1}GdipGetAdjustableArrowCapMiddleInset"]
1950 pub fn GdipGetAdjustableArrowCapMiddleInset(
1951 cap: *mut GpAdjustableArrowCap,
1952 middleInset: *mut REAL,
1953 ) -> GpStatus;
1954}
1955extern "C" {
1956 #[link_name = "\u{1}GdipSetAdjustableArrowCapFillState"]
1957 pub fn GdipSetAdjustableArrowCapFillState(
1958 cap: *mut GpAdjustableArrowCap,
1959 fillState: BOOL,
1960 ) -> GpStatus;
1961}
1962extern "C" {
1963 #[link_name = "\u{1}GdipGetAdjustableArrowCapFillState"]
1964 pub fn GdipGetAdjustableArrowCapFillState(
1965 cap: *mut GpAdjustableArrowCap,
1966 fillState: *mut BOOL,
1967 ) -> GpStatus;
1968}
1969extern "C" {
1970 #[link_name = "\u{1}GdipLoadImageFromStream"]
1971 pub fn GdipLoadImageFromStream(stream: *mut IStream, image: *mut *mut GpImage) -> GpStatus;
1972}
1973extern "C" {
1974 #[link_name = "\u{1}GdipLoadImageFromFile"]
1975 pub fn GdipLoadImageFromFile(filename: *const WCHAR, image: *mut *mut GpImage) -> GpStatus;
1976}
1977extern "C" {
1978 #[link_name = "\u{1}GdipLoadImageFromStreamICM"]
1979 pub fn GdipLoadImageFromStreamICM(stream: *mut IStream, image: *mut *mut GpImage) -> GpStatus;
1980}
1981extern "C" {
1982 #[link_name = "\u{1}GdipLoadImageFromFileICM"]
1983 pub fn GdipLoadImageFromFileICM(filename: *const WCHAR, image: *mut *mut GpImage) -> GpStatus;
1984}
1985extern "C" {
1986 #[link_name = "\u{1}GdipCloneImage"]
1987 pub fn GdipCloneImage(image: *mut GpImage, cloneImage: *mut *mut GpImage) -> GpStatus;
1988}
1989extern "C" {
1990 #[link_name = "\u{1}GdipDisposeImage"]
1991 pub fn GdipDisposeImage(image: *mut GpImage) -> GpStatus;
1992}
1993extern "C" {
1994 #[link_name = "\u{1}GdipSaveImageToFile"]
1995 pub fn GdipSaveImageToFile(
1996 image: *mut GpImage,
1997 filename: *const WCHAR,
1998 clsidEncoder: *const CLSID,
1999 encoderParams: *const EncoderParameters,
2000 ) -> GpStatus;
2001}
2002extern "C" {
2003 #[link_name = "\u{1}GdipSaveImageToStream"]
2004 pub fn GdipSaveImageToStream(
2005 image: *mut GpImage,
2006 stream: *mut IStream,
2007 clsidEncoder: *const CLSID,
2008 encoderParams: *const EncoderParameters,
2009 ) -> GpStatus;
2010}
2011extern "C" {
2012 #[link_name = "\u{1}GdipSaveAdd"]
2013 pub fn GdipSaveAdd(image: *mut GpImage, encoderParams: *const EncoderParameters) -> GpStatus;
2014}
2015extern "C" {
2016 #[link_name = "\u{1}GdipSaveAddImage"]
2017 pub fn GdipSaveAddImage(
2018 image: *mut GpImage,
2019 newImage: *mut GpImage,
2020 encoderParams: *const EncoderParameters,
2021 ) -> GpStatus;
2022}
2023extern "C" {
2024 #[link_name = "\u{1}GdipGetImageGraphicsContext"]
2025 pub fn GdipGetImageGraphicsContext(
2026 image: *mut GpImage,
2027 graphics: *mut *mut GpGraphics,
2028 ) -> GpStatus;
2029}
2030extern "C" {
2031 #[link_name = "\u{1}GdipGetImageBounds"]
2032 pub fn GdipGetImageBounds(
2033 image: *mut GpImage,
2034 srcRect: *mut GpRectF,
2035 srcUnit: *mut GpUnit,
2036 ) -> GpStatus;
2037}
2038extern "C" {
2039 #[link_name = "\u{1}GdipGetImageDimension"]
2040 pub fn GdipGetImageDimension(
2041 image: *mut GpImage,
2042 width: *mut REAL,
2043 height: *mut REAL,
2044 ) -> GpStatus;
2045}
2046extern "C" {
2047 #[link_name = "\u{1}GdipGetImageType"]
2048 pub fn GdipGetImageType(image: *mut GpImage, type_: *mut ImageType) -> GpStatus;
2049}
2050extern "C" {
2051 #[link_name = "\u{1}GdipGetImageWidth"]
2052 pub fn GdipGetImageWidth(image: *mut GpImage, width: *mut UINT) -> GpStatus;
2053}
2054extern "C" {
2055 #[link_name = "\u{1}GdipGetImageHeight"]
2056 pub fn GdipGetImageHeight(image: *mut GpImage, height: *mut UINT) -> GpStatus;
2057}
2058extern "C" {
2059 #[link_name = "\u{1}GdipGetImageHorizontalResolution"]
2060 pub fn GdipGetImageHorizontalResolution(image: *mut GpImage, resolution: *mut REAL)
2061 -> GpStatus;
2062}
2063extern "C" {
2064 #[link_name = "\u{1}GdipGetImageVerticalResolution"]
2065 pub fn GdipGetImageVerticalResolution(image: *mut GpImage, resolution: *mut REAL) -> GpStatus;
2066}
2067extern "C" {
2068 #[link_name = "\u{1}GdipGetImageFlags"]
2069 pub fn GdipGetImageFlags(image: *mut GpImage, flags: *mut UINT) -> GpStatus;
2070}
2071extern "C" {
2072 #[link_name = "\u{1}GdipGetImageRawFormat"]
2073 pub fn GdipGetImageRawFormat(image: *mut GpImage, format: *mut GUID) -> GpStatus;
2074}
2075extern "C" {
2076 #[link_name = "\u{1}GdipGetImagePixelFormat"]
2077 pub fn GdipGetImagePixelFormat(image: *mut GpImage, format: *mut PixelFormat) -> GpStatus;
2078}
2079extern "C" {
2080 #[link_name = "\u{1}GdipGetImageThumbnail"]
2081 pub fn GdipGetImageThumbnail(
2082 image: *mut GpImage,
2083 thumbWidth: UINT,
2084 thumbHeight: UINT,
2085 thumbImage: *mut *mut GpImage,
2086 callback: GetThumbnailImageAbort,
2087 callbackData: *mut c_void,
2088 ) -> GpStatus;
2089}
2090extern "C" {
2091 #[link_name = "\u{1}GdipGetEncoderParameterListSize"]
2092 pub fn GdipGetEncoderParameterListSize(
2093 image: *mut GpImage,
2094 clsidEncoder: *const CLSID,
2095 size: *mut UINT,
2096 ) -> GpStatus;
2097}
2098extern "C" {
2099 #[link_name = "\u{1}GdipGetEncoderParameterList"]
2100 pub fn GdipGetEncoderParameterList(
2101 image: *mut GpImage,
2102 clsidEncoder: *const CLSID,
2103 size: UINT,
2104 buffer: *mut EncoderParameters,
2105 ) -> GpStatus;
2106}
2107extern "C" {
2108 #[link_name = "\u{1}GdipImageGetFrameDimensionsCount"]
2109 pub fn GdipImageGetFrameDimensionsCount(image: *mut GpImage, count: *mut UINT) -> GpStatus;
2110}
2111extern "C" {
2112 #[link_name = "\u{1}GdipImageGetFrameDimensionsList"]
2113 pub fn GdipImageGetFrameDimensionsList(
2114 image: *mut GpImage,
2115 dimensionIDs: *mut GUID,
2116 count: UINT,
2117 ) -> GpStatus;
2118}
2119extern "C" {
2120 #[link_name = "\u{1}GdipImageGetFrameCount"]
2121 pub fn GdipImageGetFrameCount(
2122 image: *mut GpImage,
2123 dimensionID: *const GUID,
2124 count: *mut UINT,
2125 ) -> GpStatus;
2126}
2127extern "C" {
2128 #[link_name = "\u{1}GdipImageSelectActiveFrame"]
2129 pub fn GdipImageSelectActiveFrame(
2130 image: *mut GpImage,
2131 dimensionID: *const GUID,
2132 frameIndex: UINT,
2133 ) -> GpStatus;
2134}
2135extern "C" {
2136 #[link_name = "\u{1}GdipImageRotateFlip"]
2137 pub fn GdipImageRotateFlip(image: *mut GpImage, rfType: RotateFlipType) -> GpStatus;
2138}
2139extern "C" {
2140 #[link_name = "\u{1}GdipGetImagePalette"]
2141 pub fn GdipGetImagePalette(
2142 image: *mut GpImage,
2143 palette: *mut ColorPalette,
2144 size: INT,
2145 ) -> GpStatus;
2146}
2147extern "C" {
2148 #[link_name = "\u{1}GdipSetImagePalette"]
2149 pub fn GdipSetImagePalette(image: *mut GpImage, palette: *const ColorPalette) -> GpStatus;
2150}
2151extern "C" {
2152 #[link_name = "\u{1}GdipGetImagePaletteSize"]
2153 pub fn GdipGetImagePaletteSize(image: *mut GpImage, size: *mut INT) -> GpStatus;
2154}
2155extern "C" {
2156 #[link_name = "\u{1}GdipGetPropertyCount"]
2157 pub fn GdipGetPropertyCount(image: *mut GpImage, numOfProperty: *mut UINT) -> GpStatus;
2158}
2159extern "C" {
2160 #[link_name = "\u{1}GdipGetPropertyIdList"]
2161 pub fn GdipGetPropertyIdList(
2162 image: *mut GpImage,
2163 numOfProperty: UINT,
2164 list: *mut PROPID,
2165 ) -> GpStatus;
2166}
2167extern "C" {
2168 #[link_name = "\u{1}GdipGetPropertyItemSize"]
2169 pub fn GdipGetPropertyItemSize(
2170 image: *mut GpImage,
2171 propId: PROPID,
2172 size: *mut UINT,
2173 ) -> GpStatus;
2174}
2175extern "C" {
2176 #[link_name = "\u{1}GdipGetPropertyItem"]
2177 pub fn GdipGetPropertyItem(
2178 image: *mut GpImage,
2179 propId: PROPID,
2180 propSize: UINT,
2181 buffer: *mut PropertyItem,
2182 ) -> GpStatus;
2183}
2184extern "C" {
2185 #[link_name = "\u{1}GdipGetPropertySize"]
2186 pub fn GdipGetPropertySize(
2187 image: *mut GpImage,
2188 totalBufferSize: *mut UINT,
2189 numProperties: *mut UINT,
2190 ) -> GpStatus;
2191}
2192extern "C" {
2193 #[link_name = "\u{1}GdipGetAllPropertyItems"]
2194 pub fn GdipGetAllPropertyItems(
2195 image: *mut GpImage,
2196 totalBufferSize: UINT,
2197 numProperties: UINT,
2198 allItems: *mut PropertyItem,
2199 ) -> GpStatus;
2200}
2201extern "C" {
2202 #[link_name = "\u{1}GdipRemovePropertyItem"]
2203 pub fn GdipRemovePropertyItem(image: *mut GpImage, propId: PROPID) -> GpStatus;
2204}
2205extern "C" {
2206 #[link_name = "\u{1}GdipSetPropertyItem"]
2207 pub fn GdipSetPropertyItem(image: *mut GpImage, item: *const PropertyItem) -> GpStatus;
2208}
2209extern "C" {
2210 #[link_name = "\u{1}GdipImageForceValidation"]
2211 pub fn GdipImageForceValidation(image: *mut GpImage) -> GpStatus;
2212}
2213extern "C" {
2214 #[link_name = "\u{1}GdipCreateBitmapFromStream"]
2215 pub fn GdipCreateBitmapFromStream(stream: *mut IStream, bitmap: *mut *mut GpBitmap)
2216 -> GpStatus;
2217}
2218extern "C" {
2219 #[link_name = "\u{1}GdipCreateBitmapFromFile"]
2220 pub fn GdipCreateBitmapFromFile(filename: *const WCHAR, bitmap: *mut *mut GpBitmap)
2221 -> GpStatus;
2222}
2223extern "C" {
2224 #[link_name = "\u{1}GdipCreateBitmapFromStreamICM"]
2225 pub fn GdipCreateBitmapFromStreamICM(
2226 stream: *mut IStream,
2227 bitmap: *mut *mut GpBitmap,
2228 ) -> GpStatus;
2229}
2230extern "C" {
2231 #[link_name = "\u{1}GdipCreateBitmapFromFileICM"]
2232 pub fn GdipCreateBitmapFromFileICM(
2233 filename: *const WCHAR,
2234 bitmap: *mut *mut GpBitmap,
2235 ) -> GpStatus;
2236}
2237extern "C" {
2238 #[link_name = "\u{1}GdipCreateBitmapFromScan0"]
2239 pub fn GdipCreateBitmapFromScan0(
2240 width: INT,
2241 height: INT,
2242 stride: INT,
2243 format: PixelFormat,
2244 scan0: *mut BYTE,
2245 bitmap: *mut *mut GpBitmap,
2246 ) -> GpStatus;
2247}
2248extern "C" {
2249 #[link_name = "\u{1}GdipCreateBitmapFromGraphics"]
2250 pub fn GdipCreateBitmapFromGraphics(
2251 width: INT,
2252 height: INT,
2253 target: *mut GpGraphics,
2254 bitmap: *mut *mut GpBitmap,
2255 ) -> GpStatus;
2256}
2257extern "C" {
2258 #[link_name = "\u{1}GdipCreateBitmapFromDirectDrawSurface"]
2259 pub fn GdipCreateBitmapFromDirectDrawSurface(
2260 surface: *mut IDirectDrawSurface7,
2261 bitmap: *mut *mut GpBitmap,
2262 ) -> GpStatus;
2263}
2264extern "C" {
2265 #[link_name = "\u{1}GdipCreateBitmapFromGdiDib"]
2266 pub fn GdipCreateBitmapFromGdiDib(
2267 gdiBitmapInfo: *const BITMAPINFO,
2268 gdiBitmapData: *mut c_void,
2269 bitmap: *mut *mut GpBitmap,
2270 ) -> GpStatus;
2271}
2272extern "C" {
2273 #[link_name = "\u{1}GdipCreateBitmapFromHBITMAP"]
2274 pub fn GdipCreateBitmapFromHBITMAP(
2275 hbm: HBITMAP,
2276 hpal: HPALETTE,
2277 bitmap: *mut *mut GpBitmap,
2278 ) -> GpStatus;
2279}
2280extern "C" {
2281 #[link_name = "\u{1}GdipCreateHBITMAPFromBitmap"]
2282 pub fn GdipCreateHBITMAPFromBitmap(
2283 bitmap: *mut GpBitmap,
2284 hbmReturn: *mut HBITMAP,
2285 background: ARGB,
2286 ) -> GpStatus;
2287}
2288extern "C" {
2289 #[link_name = "\u{1}GdipCreateBitmapFromHICON"]
2290 pub fn GdipCreateBitmapFromHICON(hicon: HICON, bitmap: *mut *mut GpBitmap) -> GpStatus;
2291}
2292extern "C" {
2293 #[link_name = "\u{1}GdipCreateHICONFromBitmap"]
2294 pub fn GdipCreateHICONFromBitmap(bitmap: *mut GpBitmap, hbmReturn: *mut HICON) -> GpStatus;
2295}
2296extern "C" {
2297 #[link_name = "\u{1}GdipCreateBitmapFromResource"]
2298 pub fn GdipCreateBitmapFromResource(
2299 hInstance: HINSTANCE,
2300 lpBitmapName: *const WCHAR,
2301 bitmap: *mut *mut GpBitmap,
2302 ) -> GpStatus;
2303}
2304extern "C" {
2305 #[link_name = "\u{1}GdipCloneBitmapArea"]
2306 pub fn GdipCloneBitmapArea(
2307 x: REAL,
2308 y: REAL,
2309 width: REAL,
2310 height: REAL,
2311 format: PixelFormat,
2312 srcBitmap: *mut GpBitmap,
2313 dstBitmap: *mut *mut GpBitmap,
2314 ) -> GpStatus;
2315}
2316extern "C" {
2317 #[link_name = "\u{1}GdipCloneBitmapAreaI"]
2318 pub fn GdipCloneBitmapAreaI(
2319 x: INT,
2320 y: INT,
2321 width: INT,
2322 height: INT,
2323 format: PixelFormat,
2324 srcBitmap: *mut GpBitmap,
2325 dstBitmap: *mut *mut GpBitmap,
2326 ) -> GpStatus;
2327}
2328extern "C" {
2329 #[link_name = "\u{1}GdipBitmapLockBits"]
2330 pub fn GdipBitmapLockBits(
2331 bitmap: *mut GpBitmap,
2332 rect: *const GpRect,
2333 flags: UINT,
2334 format: PixelFormat,
2335 lockedBitmapData: *mut BitmapData,
2336 ) -> GpStatus;
2337}
2338extern "C" {
2339 #[link_name = "\u{1}GdipBitmapUnlockBits"]
2340 pub fn GdipBitmapUnlockBits(
2341 bitmap: *mut GpBitmap,
2342 lockedBitmapData: *mut BitmapData,
2343 ) -> GpStatus;
2344}
2345extern "C" {
2346 #[link_name = "\u{1}GdipBitmapGetPixel"]
2347 pub fn GdipBitmapGetPixel(bitmap: *mut GpBitmap, x: INT, y: INT, color: *mut ARGB) -> GpStatus;
2348}
2349extern "C" {
2350 #[link_name = "\u{1}GdipBitmapSetPixel"]
2351 pub fn GdipBitmapSetPixel(bitmap: *mut GpBitmap, x: INT, y: INT, color: ARGB) -> GpStatus;
2352}
2353extern "C" {
2354 #[link_name = "\u{1}GdipBitmapSetResolution"]
2355 pub fn GdipBitmapSetResolution(bitmap: *mut GpBitmap, xdpi: REAL, ydpi: REAL) -> GpStatus;
2356}
2357extern "C" {
2358 #[link_name = "\u{1}GdipCreateImageAttributes"]
2359 pub fn GdipCreateImageAttributes(imageattr: *mut *mut GpImageAttributes) -> GpStatus;
2360}
2361extern "C" {
2362 #[link_name = "\u{1}GdipCloneImageAttributes"]
2363 pub fn GdipCloneImageAttributes(
2364 imageattr: *const GpImageAttributes,
2365 cloneImageattr: *mut *mut GpImageAttributes,
2366 ) -> GpStatus;
2367}
2368extern "C" {
2369 #[link_name = "\u{1}GdipDisposeImageAttributes"]
2370 pub fn GdipDisposeImageAttributes(imageattr: *mut GpImageAttributes) -> GpStatus;
2371}
2372extern "C" {
2373 #[link_name = "\u{1}GdipSetImageAttributesToIdentity"]
2374 pub fn GdipSetImageAttributesToIdentity(
2375 imageattr: *mut GpImageAttributes,
2376 type_: ColorAdjustType,
2377 ) -> GpStatus;
2378}
2379extern "C" {
2380 #[link_name = "\u{1}GdipResetImageAttributes"]
2381 pub fn GdipResetImageAttributes(
2382 imageattr: *mut GpImageAttributes,
2383 type_: ColorAdjustType,
2384 ) -> GpStatus;
2385}
2386extern "C" {
2387 #[link_name = "\u{1}GdipSetImageAttributesColorMatrix"]
2388 pub fn GdipSetImageAttributesColorMatrix(
2389 imageattr: *mut GpImageAttributes,
2390 type_: ColorAdjustType,
2391 enableFlag: BOOL,
2392 colorMatrix: *const ColorMatrix,
2393 grayMatrix: *const ColorMatrix,
2394 flags: ColorMatrixFlags,
2395 ) -> GpStatus;
2396}
2397extern "C" {
2398 #[link_name = "\u{1}GdipSetImageAttributesThreshold"]
2399 pub fn GdipSetImageAttributesThreshold(
2400 imageattr: *mut GpImageAttributes,
2401 type_: ColorAdjustType,
2402 enableFlag: BOOL,
2403 threshold: REAL,
2404 ) -> GpStatus;
2405}
2406extern "C" {
2407 #[link_name = "\u{1}GdipSetImageAttributesGamma"]
2408 pub fn GdipSetImageAttributesGamma(
2409 imageattr: *mut GpImageAttributes,
2410 type_: ColorAdjustType,
2411 enableFlag: BOOL,
2412 gamma: REAL,
2413 ) -> GpStatus;
2414}
2415extern "C" {
2416 #[link_name = "\u{1}GdipSetImageAttributesNoOp"]
2417 pub fn GdipSetImageAttributesNoOp(
2418 imageattr: *mut GpImageAttributes,
2419 type_: ColorAdjustType,
2420 enableFlag: BOOL,
2421 ) -> GpStatus;
2422}
2423extern "C" {
2424 #[link_name = "\u{1}GdipSetImageAttributesColorKeys"]
2425 pub fn GdipSetImageAttributesColorKeys(
2426 imageattr: *mut GpImageAttributes,
2427 type_: ColorAdjustType,
2428 enableFlag: BOOL,
2429 colorLow: ARGB,
2430 colorHigh: ARGB,
2431 ) -> GpStatus;
2432}
2433extern "C" {
2434 #[link_name = "\u{1}GdipSetImageAttributesOutputChannel"]
2435 pub fn GdipSetImageAttributesOutputChannel(
2436 imageattr: *mut GpImageAttributes,
2437 type_: ColorAdjustType,
2438 enableFlag: BOOL,
2439 channelFlags: ColorChannelFlags,
2440 ) -> GpStatus;
2441}
2442extern "C" {
2443 #[link_name = "\u{1}GdipSetImageAttributesOutputChannelColorProfile"]
2444 pub fn GdipSetImageAttributesOutputChannelColorProfile(
2445 imageattr: *mut GpImageAttributes,
2446 type_: ColorAdjustType,
2447 enableFlag: BOOL,
2448 colorProfileFilename: *const WCHAR,
2449 ) -> GpStatus;
2450}
2451extern "C" {
2452 #[link_name = "\u{1}GdipSetImageAttributesRemapTable"]
2453 pub fn GdipSetImageAttributesRemapTable(
2454 imageattr: *mut GpImageAttributes,
2455 type_: ColorAdjustType,
2456 enableFlag: BOOL,
2457 mapSize: UINT,
2458 map: *const ColorMap,
2459 ) -> GpStatus;
2460}
2461extern "C" {
2462 #[link_name = "\u{1}GdipSetImageAttributesWrapMode"]
2463 pub fn GdipSetImageAttributesWrapMode(
2464 imageAttr: *mut GpImageAttributes,
2465 wrap: WrapMode,
2466 argb: ARGB,
2467 clamp: BOOL,
2468 ) -> GpStatus;
2469}
2470extern "C" {
2471 #[link_name = "\u{1}GdipSetImageAttributesICMMode"]
2472 pub fn GdipSetImageAttributesICMMode(imageAttr: *mut GpImageAttributes, on: BOOL) -> GpStatus;
2473}
2474extern "C" {
2475 #[link_name = "\u{1}GdipGetImageAttributesAdjustedPalette"]
2476 pub fn GdipGetImageAttributesAdjustedPalette(
2477 imageAttr: *mut GpImageAttributes,
2478 colorPalette: *mut ColorPalette,
2479 colorAdjustType: ColorAdjustType,
2480 ) -> GpStatus;
2481}
2482extern "C" {
2483 #[link_name = "\u{1}GdipFlush"]
2484 pub fn GdipFlush(graphics: *mut GpGraphics, intention: GpFlushIntention) -> GpStatus;
2485}
2486extern "C" {
2487 #[link_name = "\u{1}GdipCreateFromHDC"]
2488 pub fn GdipCreateFromHDC(hdc: HDC, graphics: *mut *mut GpGraphics) -> GpStatus;
2489}
2490extern "C" {
2491 #[link_name = "\u{1}GdipCreateFromHDC2"]
2492 pub fn GdipCreateFromHDC2(
2493 hdc: HDC,
2494 hDevice: HANDLE,
2495 graphics: *mut *mut GpGraphics,
2496 ) -> GpStatus;
2497}
2498extern "C" {
2499 #[link_name = "\u{1}GdipCreateFromHWND"]
2500 pub fn GdipCreateFromHWND(hwnd: HWND, graphics: *mut *mut GpGraphics) -> GpStatus;
2501}
2502extern "C" {
2503 #[link_name = "\u{1}GdipCreateFromHWNDICM"]
2504 pub fn GdipCreateFromHWNDICM(hwnd: HWND, graphics: *mut *mut GpGraphics) -> GpStatus;
2505}
2506extern "C" {
2507 #[link_name = "\u{1}GdipDeleteGraphics"]
2508 pub fn GdipDeleteGraphics(graphics: *mut GpGraphics) -> GpStatus;
2509}
2510extern "C" {
2511 #[link_name = "\u{1}GdipGetDC"]
2512 pub fn GdipGetDC(graphics: *mut GpGraphics, hdc: *mut HDC) -> GpStatus;
2513}
2514extern "C" {
2515 #[link_name = "\u{1}GdipReleaseDC"]
2516 pub fn GdipReleaseDC(graphics: *mut GpGraphics, hdc: HDC) -> GpStatus;
2517}
2518extern "C" {
2519 #[link_name = "\u{1}GdipSetCompositingMode"]
2520 pub fn GdipSetCompositingMode(
2521 graphics: *mut GpGraphics,
2522 compositingMode: CompositingMode,
2523 ) -> GpStatus;
2524}
2525extern "C" {
2526 #[link_name = "\u{1}GdipGetCompositingMode"]
2527 pub fn GdipGetCompositingMode(
2528 graphics: *mut GpGraphics,
2529 compositingMode: *mut CompositingMode,
2530 ) -> GpStatus;
2531}
2532extern "C" {
2533 #[link_name = "\u{1}GdipSetRenderingOrigin"]
2534 pub fn GdipSetRenderingOrigin(graphics: *mut GpGraphics, x: INT, y: INT) -> GpStatus;
2535}
2536extern "C" {
2537 #[link_name = "\u{1}GdipGetRenderingOrigin"]
2538 pub fn GdipGetRenderingOrigin(graphics: *mut GpGraphics, x: *mut INT, y: *mut INT) -> GpStatus;
2539}
2540extern "C" {
2541 #[link_name = "\u{1}GdipSetCompositingQuality"]
2542 pub fn GdipSetCompositingQuality(
2543 graphics: *mut GpGraphics,
2544 compositingQuality: CompositingQuality,
2545 ) -> GpStatus;
2546}
2547extern "C" {
2548 #[link_name = "\u{1}GdipGetCompositingQuality"]
2549 pub fn GdipGetCompositingQuality(
2550 graphics: *mut GpGraphics,
2551 compositingQuality: *mut CompositingQuality,
2552 ) -> GpStatus;
2553}
2554extern "C" {
2555 #[link_name = "\u{1}GdipSetSmoothingMode"]
2556 pub fn GdipSetSmoothingMode(
2557 graphics: *mut GpGraphics,
2558 smoothingMode: SmoothingMode,
2559 ) -> GpStatus;
2560}
2561extern "C" {
2562 #[link_name = "\u{1}GdipGetSmoothingMode"]
2563 pub fn GdipGetSmoothingMode(
2564 graphics: *mut GpGraphics,
2565 smoothingMode: *mut SmoothingMode,
2566 ) -> GpStatus;
2567}
2568extern "C" {
2569 #[link_name = "\u{1}GdipSetPixelOffsetMode"]
2570 pub fn GdipSetPixelOffsetMode(
2571 graphics: *mut GpGraphics,
2572 pixelOffsetMode: PixelOffsetMode,
2573 ) -> GpStatus;
2574}
2575extern "C" {
2576 #[link_name = "\u{1}GdipGetPixelOffsetMode"]
2577 pub fn GdipGetPixelOffsetMode(
2578 graphics: *mut GpGraphics,
2579 pixelOffsetMode: *mut PixelOffsetMode,
2580 ) -> GpStatus;
2581}
2582extern "C" {
2583 #[link_name = "\u{1}GdipSetTextRenderingHint"]
2584 pub fn GdipSetTextRenderingHint(graphics: *mut GpGraphics, mode: TextRenderingHint)
2585 -> GpStatus;
2586}
2587extern "C" {
2588 #[link_name = "\u{1}GdipGetTextRenderingHint"]
2589 pub fn GdipGetTextRenderingHint(
2590 graphics: *mut GpGraphics,
2591 mode: *mut TextRenderingHint,
2592 ) -> GpStatus;
2593}
2594extern "C" {
2595 #[link_name = "\u{1}GdipSetTextContrast"]
2596 pub fn GdipSetTextContrast(graphics: *mut GpGraphics, contrast: UINT) -> GpStatus;
2597}
2598extern "C" {
2599 #[link_name = "\u{1}GdipGetTextContrast"]
2600 pub fn GdipGetTextContrast(graphics: *mut GpGraphics, contrast: *mut UINT) -> GpStatus;
2601}
2602extern "C" {
2603 #[link_name = "\u{1}GdipSetInterpolationMode"]
2604 pub fn GdipSetInterpolationMode(
2605 graphics: *mut GpGraphics,
2606 interpolationMode: InterpolationMode,
2607 ) -> GpStatus;
2608}
2609extern "C" {
2610 #[link_name = "\u{1}GdipGetInterpolationMode"]
2611 pub fn GdipGetInterpolationMode(
2612 graphics: *mut GpGraphics,
2613 interpolationMode: *mut InterpolationMode,
2614 ) -> GpStatus;
2615}
2616extern "C" {
2617 #[link_name = "\u{1}GdipSetWorldTransform"]
2618 pub fn GdipSetWorldTransform(graphics: *mut GpGraphics, matrix: *mut GpMatrix) -> GpStatus;
2619}
2620extern "C" {
2621 #[link_name = "\u{1}GdipResetWorldTransform"]
2622 pub fn GdipResetWorldTransform(graphics: *mut GpGraphics) -> GpStatus;
2623}
2624extern "C" {
2625 #[link_name = "\u{1}GdipMultiplyWorldTransform"]
2626 pub fn GdipMultiplyWorldTransform(
2627 graphics: *mut GpGraphics,
2628 matrix: *const GpMatrix,
2629 order: GpMatrixOrder,
2630 ) -> GpStatus;
2631}
2632extern "C" {
2633 #[link_name = "\u{1}GdipTranslateWorldTransform"]
2634 pub fn GdipTranslateWorldTransform(
2635 graphics: *mut GpGraphics,
2636 dx: REAL,
2637 dy: REAL,
2638 order: GpMatrixOrder,
2639 ) -> GpStatus;
2640}
2641extern "C" {
2642 #[link_name = "\u{1}GdipScaleWorldTransform"]
2643 pub fn GdipScaleWorldTransform(
2644 graphics: *mut GpGraphics,
2645 sx: REAL,
2646 sy: REAL,
2647 order: GpMatrixOrder,
2648 ) -> GpStatus;
2649}
2650extern "C" {
2651 #[link_name = "\u{1}GdipRotateWorldTransform"]
2652 pub fn GdipRotateWorldTransform(
2653 graphics: *mut GpGraphics,
2654 angle: REAL,
2655 order: GpMatrixOrder,
2656 ) -> GpStatus;
2657}
2658extern "C" {
2659 #[link_name = "\u{1}GdipGetWorldTransform"]
2660 pub fn GdipGetWorldTransform(graphics: *mut GpGraphics, matrix: *mut GpMatrix) -> GpStatus;
2661}
2662extern "C" {
2663 #[link_name = "\u{1}GdipResetPageTransform"]
2664 pub fn GdipResetPageTransform(graphics: *mut GpGraphics) -> GpStatus;
2665}
2666extern "C" {
2667 #[link_name = "\u{1}GdipGetPageUnit"]
2668 pub fn GdipGetPageUnit(graphics: *mut GpGraphics, unit: *mut GpUnit) -> GpStatus;
2669}
2670extern "C" {
2671 #[link_name = "\u{1}GdipGetPageScale"]
2672 pub fn GdipGetPageScale(graphics: *mut GpGraphics, scale: *mut REAL) -> GpStatus;
2673}
2674extern "C" {
2675 #[link_name = "\u{1}GdipSetPageUnit"]
2676 pub fn GdipSetPageUnit(graphics: *mut GpGraphics, unit: GpUnit) -> GpStatus;
2677}
2678extern "C" {
2679 #[link_name = "\u{1}GdipSetPageScale"]
2680 pub fn GdipSetPageScale(graphics: *mut GpGraphics, scale: REAL) -> GpStatus;
2681}
2682extern "C" {
2683 #[link_name = "\u{1}GdipGetDpiX"]
2684 pub fn GdipGetDpiX(graphics: *mut GpGraphics, dpi: *mut REAL) -> GpStatus;
2685}
2686extern "C" {
2687 #[link_name = "\u{1}GdipGetDpiY"]
2688 pub fn GdipGetDpiY(graphics: *mut GpGraphics, dpi: *mut REAL) -> GpStatus;
2689}
2690extern "C" {
2691 #[link_name = "\u{1}GdipTransformPoints"]
2692 pub fn GdipTransformPoints(
2693 graphics: *mut GpGraphics,
2694 destSpace: GpCoordinateSpace,
2695 srcSpace: GpCoordinateSpace,
2696 points: *mut GpPointF,
2697 count: INT,
2698 ) -> GpStatus;
2699}
2700extern "C" {
2701 #[link_name = "\u{1}GdipTransformPointsI"]
2702 pub fn GdipTransformPointsI(
2703 graphics: *mut GpGraphics,
2704 destSpace: GpCoordinateSpace,
2705 srcSpace: GpCoordinateSpace,
2706 points: *mut GpPoint,
2707 count: INT,
2708 ) -> GpStatus;
2709}
2710extern "C" {
2711 #[link_name = "\u{1}GdipGetNearestColor"]
2712 pub fn GdipGetNearestColor(graphics: *mut GpGraphics, argb: *mut ARGB) -> GpStatus;
2713}
2714extern "C" {
2715 #[link_name = "\u{1}GdipCreateHalftonePalette"]
2716 pub fn GdipCreateHalftonePalette() -> HPALETTE;
2717}
2718extern "C" {
2719 #[link_name = "\u{1}GdipDrawLine"]
2720 pub fn GdipDrawLine(
2721 graphics: *mut GpGraphics,
2722 pen: *mut GpPen,
2723 x1: REAL,
2724 y1: REAL,
2725 x2: REAL,
2726 y2: REAL,
2727 ) -> GpStatus;
2728}
2729extern "C" {
2730 #[link_name = "\u{1}GdipDrawLineI"]
2731 pub fn GdipDrawLineI(
2732 graphics: *mut GpGraphics,
2733 pen: *mut GpPen,
2734 x1: INT,
2735 y1: INT,
2736 x2: INT,
2737 y2: INT,
2738 ) -> GpStatus;
2739}
2740extern "C" {
2741 #[link_name = "\u{1}GdipDrawLines"]
2742 pub fn GdipDrawLines(
2743 graphics: *mut GpGraphics,
2744 pen: *mut GpPen,
2745 points: *const GpPointF,
2746 count: INT,
2747 ) -> GpStatus;
2748}
2749extern "C" {
2750 #[link_name = "\u{1}GdipDrawLinesI"]
2751 pub fn GdipDrawLinesI(
2752 graphics: *mut GpGraphics,
2753 pen: *mut GpPen,
2754 points: *const GpPoint,
2755 count: INT,
2756 ) -> GpStatus;
2757}
2758extern "C" {
2759 #[link_name = "\u{1}GdipDrawArc"]
2760 pub fn GdipDrawArc(
2761 graphics: *mut GpGraphics,
2762 pen: *mut GpPen,
2763 x: REAL,
2764 y: REAL,
2765 width: REAL,
2766 height: REAL,
2767 startAngle: REAL,
2768 sweepAngle: REAL,
2769 ) -> GpStatus;
2770}
2771extern "C" {
2772 #[link_name = "\u{1}GdipDrawArcI"]
2773 pub fn GdipDrawArcI(
2774 graphics: *mut GpGraphics,
2775 pen: *mut GpPen,
2776 x: INT,
2777 y: INT,
2778 width: INT,
2779 height: INT,
2780 startAngle: REAL,
2781 sweepAngle: REAL,
2782 ) -> GpStatus;
2783}
2784extern "C" {
2785 #[link_name = "\u{1}GdipDrawBezier"]
2786 pub fn GdipDrawBezier(
2787 graphics: *mut GpGraphics,
2788 pen: *mut GpPen,
2789 x1: REAL,
2790 y1: REAL,
2791 x2: REAL,
2792 y2: REAL,
2793 x3: REAL,
2794 y3: REAL,
2795 x4: REAL,
2796 y4: REAL,
2797 ) -> GpStatus;
2798}
2799extern "C" {
2800 #[link_name = "\u{1}GdipDrawBezierI"]
2801 pub fn GdipDrawBezierI(
2802 graphics: *mut GpGraphics,
2803 pen: *mut GpPen,
2804 x1: INT,
2805 y1: INT,
2806 x2: INT,
2807 y2: INT,
2808 x3: INT,
2809 y3: INT,
2810 x4: INT,
2811 y4: INT,
2812 ) -> GpStatus;
2813}
2814extern "C" {
2815 #[link_name = "\u{1}GdipDrawBeziers"]
2816 pub fn GdipDrawBeziers(
2817 graphics: *mut GpGraphics,
2818 pen: *mut GpPen,
2819 points: *const GpPointF,
2820 count: INT,
2821 ) -> GpStatus;
2822}
2823extern "C" {
2824 #[link_name = "\u{1}GdipDrawBeziersI"]
2825 pub fn GdipDrawBeziersI(
2826 graphics: *mut GpGraphics,
2827 pen: *mut GpPen,
2828 points: *const GpPoint,
2829 count: INT,
2830 ) -> GpStatus;
2831}
2832extern "C" {
2833 #[link_name = "\u{1}GdipDrawRectangle"]
2834 pub fn GdipDrawRectangle(
2835 graphics: *mut GpGraphics,
2836 pen: *mut GpPen,
2837 x: REAL,
2838 y: REAL,
2839 width: REAL,
2840 height: REAL,
2841 ) -> GpStatus;
2842}
2843extern "C" {
2844 #[link_name = "\u{1}GdipDrawRectangleI"]
2845 pub fn GdipDrawRectangleI(
2846 graphics: *mut GpGraphics,
2847 pen: *mut GpPen,
2848 x: INT,
2849 y: INT,
2850 width: INT,
2851 height: INT,
2852 ) -> GpStatus;
2853}
2854extern "C" {
2855 #[link_name = "\u{1}GdipDrawRectangles"]
2856 pub fn GdipDrawRectangles(
2857 graphics: *mut GpGraphics,
2858 pen: *mut GpPen,
2859 rects: *const GpRectF,
2860 count: INT,
2861 ) -> GpStatus;
2862}
2863extern "C" {
2864 #[link_name = "\u{1}GdipDrawRectanglesI"]
2865 pub fn GdipDrawRectanglesI(
2866 graphics: *mut GpGraphics,
2867 pen: *mut GpPen,
2868 rects: *const GpRect,
2869 count: INT,
2870 ) -> GpStatus;
2871}
2872extern "C" {
2873 #[link_name = "\u{1}GdipDrawEllipse"]
2874 pub fn GdipDrawEllipse(
2875 graphics: *mut GpGraphics,
2876 pen: *mut GpPen,
2877 x: REAL,
2878 y: REAL,
2879 width: REAL,
2880 height: REAL,
2881 ) -> GpStatus;
2882}
2883extern "C" {
2884 #[link_name = "\u{1}GdipDrawEllipseI"]
2885 pub fn GdipDrawEllipseI(
2886 graphics: *mut GpGraphics,
2887 pen: *mut GpPen,
2888 x: INT,
2889 y: INT,
2890 width: INT,
2891 height: INT,
2892 ) -> GpStatus;
2893}
2894extern "C" {
2895 #[link_name = "\u{1}GdipDrawPie"]
2896 pub fn GdipDrawPie(
2897 graphics: *mut GpGraphics,
2898 pen: *mut GpPen,
2899 x: REAL,
2900 y: REAL,
2901 width: REAL,
2902 height: REAL,
2903 startAngle: REAL,
2904 sweepAngle: REAL,
2905 ) -> GpStatus;
2906}
2907extern "C" {
2908 #[link_name = "\u{1}GdipDrawPieI"]
2909 pub fn GdipDrawPieI(
2910 graphics: *mut GpGraphics,
2911 pen: *mut GpPen,
2912 x: INT,
2913 y: INT,
2914 width: INT,
2915 height: INT,
2916 startAngle: REAL,
2917 sweepAngle: REAL,
2918 ) -> GpStatus;
2919}
2920extern "C" {
2921 #[link_name = "\u{1}GdipDrawPolygon"]
2922 pub fn GdipDrawPolygon(
2923 graphics: *mut GpGraphics,
2924 pen: *mut GpPen,
2925 points: *const GpPointF,
2926 count: INT,
2927 ) -> GpStatus;
2928}
2929extern "C" {
2930 #[link_name = "\u{1}GdipDrawPolygonI"]
2931 pub fn GdipDrawPolygonI(
2932 graphics: *mut GpGraphics,
2933 pen: *mut GpPen,
2934 points: *const GpPoint,
2935 count: INT,
2936 ) -> GpStatus;
2937}
2938extern "C" {
2939 #[link_name = "\u{1}GdipDrawPath"]
2940 pub fn GdipDrawPath(graphics: *mut GpGraphics, pen: *mut GpPen, path: *mut GpPath) -> GpStatus;
2941}
2942extern "C" {
2943 #[link_name = "\u{1}GdipDrawCurve"]
2944 pub fn GdipDrawCurve(
2945 graphics: *mut GpGraphics,
2946 pen: *mut GpPen,
2947 points: *const GpPointF,
2948 count: INT,
2949 ) -> GpStatus;
2950}
2951extern "C" {
2952 #[link_name = "\u{1}GdipDrawCurveI"]
2953 pub fn GdipDrawCurveI(
2954 graphics: *mut GpGraphics,
2955 pen: *mut GpPen,
2956 points: *const GpPoint,
2957 count: INT,
2958 ) -> GpStatus;
2959}
2960extern "C" {
2961 #[link_name = "\u{1}GdipDrawCurve2"]
2962 pub fn GdipDrawCurve2(
2963 graphics: *mut GpGraphics,
2964 pen: *mut GpPen,
2965 points: *const GpPointF,
2966 count: INT,
2967 tension: REAL,
2968 ) -> GpStatus;
2969}
2970extern "C" {
2971 #[link_name = "\u{1}GdipDrawCurve2I"]
2972 pub fn GdipDrawCurve2I(
2973 graphics: *mut GpGraphics,
2974 pen: *mut GpPen,
2975 points: *const GpPoint,
2976 count: INT,
2977 tension: REAL,
2978 ) -> GpStatus;
2979}
2980extern "C" {
2981 #[link_name = "\u{1}GdipDrawCurve3"]
2982 pub fn GdipDrawCurve3(
2983 graphics: *mut GpGraphics,
2984 pen: *mut GpPen,
2985 points: *const GpPointF,
2986 count: INT,
2987 offset: INT,
2988 numberOfSegments: INT,
2989 tension: REAL,
2990 ) -> GpStatus;
2991}
2992extern "C" {
2993 #[link_name = "\u{1}GdipDrawCurve3I"]
2994 pub fn GdipDrawCurve3I(
2995 graphics: *mut GpGraphics,
2996 pen: *mut GpPen,
2997 points: *const GpPoint,
2998 count: INT,
2999 offset: INT,
3000 numberOfSegments: INT,
3001 tension: REAL,
3002 ) -> GpStatus;
3003}
3004extern "C" {
3005 #[link_name = "\u{1}GdipDrawClosedCurve"]
3006 pub fn GdipDrawClosedCurve(
3007 graphics: *mut GpGraphics,
3008 pen: *mut GpPen,
3009 points: *const GpPointF,
3010 count: INT,
3011 ) -> GpStatus;
3012}
3013extern "C" {
3014 #[link_name = "\u{1}GdipDrawClosedCurveI"]
3015 pub fn GdipDrawClosedCurveI(
3016 graphics: *mut GpGraphics,
3017 pen: *mut GpPen,
3018 points: *const GpPoint,
3019 count: INT,
3020 ) -> GpStatus;
3021}
3022extern "C" {
3023 #[link_name = "\u{1}GdipDrawClosedCurve2"]
3024 pub fn GdipDrawClosedCurve2(
3025 graphics: *mut GpGraphics,
3026 pen: *mut GpPen,
3027 points: *const GpPointF,
3028 count: INT,
3029 tension: REAL,
3030 ) -> GpStatus;
3031}
3032extern "C" {
3033 #[link_name = "\u{1}GdipDrawClosedCurve2I"]
3034 pub fn GdipDrawClosedCurve2I(
3035 graphics: *mut GpGraphics,
3036 pen: *mut GpPen,
3037 points: *const GpPoint,
3038 count: INT,
3039 tension: REAL,
3040 ) -> GpStatus;
3041}
3042extern "C" {
3043 #[link_name = "\u{1}GdipGraphicsClear"]
3044 pub fn GdipGraphicsClear(graphics: *mut GpGraphics, color: ARGB) -> GpStatus;
3045}
3046extern "C" {
3047 #[link_name = "\u{1}GdipFillRectangle"]
3048 pub fn GdipFillRectangle(
3049 graphics: *mut GpGraphics,
3050 brush: *mut GpBrush,
3051 x: REAL,
3052 y: REAL,
3053 width: REAL,
3054 height: REAL,
3055 ) -> GpStatus;
3056}
3057extern "C" {
3058 #[link_name = "\u{1}GdipFillRectangleI"]
3059 pub fn GdipFillRectangleI(
3060 graphics: *mut GpGraphics,
3061 brush: *mut GpBrush,
3062 x: INT,
3063 y: INT,
3064 width: INT,
3065 height: INT,
3066 ) -> GpStatus;
3067}
3068extern "C" {
3069 #[link_name = "\u{1}GdipFillRectangles"]
3070 pub fn GdipFillRectangles(
3071 graphics: *mut GpGraphics,
3072 brush: *mut GpBrush,
3073 rects: *const GpRectF,
3074 count: INT,
3075 ) -> GpStatus;
3076}
3077extern "C" {
3078 #[link_name = "\u{1}GdipFillRectanglesI"]
3079 pub fn GdipFillRectanglesI(
3080 graphics: *mut GpGraphics,
3081 brush: *mut GpBrush,
3082 rects: *const GpRect,
3083 count: INT,
3084 ) -> GpStatus;
3085}
3086extern "C" {
3087 #[link_name = "\u{1}GdipFillPolygon"]
3088 pub fn GdipFillPolygon(
3089 graphics: *mut GpGraphics,
3090 brush: *mut GpBrush,
3091 points: *const GpPointF,
3092 count: INT,
3093 fillMode: GpFillMode,
3094 ) -> GpStatus;
3095}
3096extern "C" {
3097 #[link_name = "\u{1}GdipFillPolygonI"]
3098 pub fn GdipFillPolygonI(
3099 graphics: *mut GpGraphics,
3100 brush: *mut GpBrush,
3101 points: *const GpPoint,
3102 count: INT,
3103 fillMode: GpFillMode,
3104 ) -> GpStatus;
3105}
3106extern "C" {
3107 #[link_name = "\u{1}GdipFillPolygon2"]
3108 pub fn GdipFillPolygon2(
3109 graphics: *mut GpGraphics,
3110 brush: *mut GpBrush,
3111 points: *const GpPointF,
3112 count: INT,
3113 ) -> GpStatus;
3114}
3115extern "C" {
3116 #[link_name = "\u{1}GdipFillPolygon2I"]
3117 pub fn GdipFillPolygon2I(
3118 graphics: *mut GpGraphics,
3119 brush: *mut GpBrush,
3120 points: *const GpPoint,
3121 count: INT,
3122 ) -> GpStatus;
3123}
3124extern "C" {
3125 #[link_name = "\u{1}GdipFillEllipse"]
3126 pub fn GdipFillEllipse(
3127 graphics: *mut GpGraphics,
3128 brush: *mut GpBrush,
3129 x: REAL,
3130 y: REAL,
3131 width: REAL,
3132 height: REAL,
3133 ) -> GpStatus;
3134}
3135extern "C" {
3136 #[link_name = "\u{1}GdipFillEllipseI"]
3137 pub fn GdipFillEllipseI(
3138 graphics: *mut GpGraphics,
3139 brush: *mut GpBrush,
3140 x: INT,
3141 y: INT,
3142 width: INT,
3143 height: INT,
3144 ) -> GpStatus;
3145}
3146extern "C" {
3147 #[link_name = "\u{1}GdipFillPie"]
3148 pub fn GdipFillPie(
3149 graphics: *mut GpGraphics,
3150 brush: *mut GpBrush,
3151 x: REAL,
3152 y: REAL,
3153 width: REAL,
3154 height: REAL,
3155 startAngle: REAL,
3156 sweepAngle: REAL,
3157 ) -> GpStatus;
3158}
3159extern "C" {
3160 #[link_name = "\u{1}GdipFillPieI"]
3161 pub fn GdipFillPieI(
3162 graphics: *mut GpGraphics,
3163 brush: *mut GpBrush,
3164 x: INT,
3165 y: INT,
3166 width: INT,
3167 height: INT,
3168 startAngle: REAL,
3169 sweepAngle: REAL,
3170 ) -> GpStatus;
3171}
3172extern "C" {
3173 #[link_name = "\u{1}GdipFillPath"]
3174 pub fn GdipFillPath(
3175 graphics: *mut GpGraphics,
3176 brush: *mut GpBrush,
3177 path: *mut GpPath,
3178 ) -> GpStatus;
3179}
3180extern "C" {
3181 #[link_name = "\u{1}GdipFillClosedCurve"]
3182 pub fn GdipFillClosedCurve(
3183 graphics: *mut GpGraphics,
3184 brush: *mut GpBrush,
3185 points: *const GpPointF,
3186 count: INT,
3187 ) -> GpStatus;
3188}
3189extern "C" {
3190 #[link_name = "\u{1}GdipFillClosedCurveI"]
3191 pub fn GdipFillClosedCurveI(
3192 graphics: *mut GpGraphics,
3193 brush: *mut GpBrush,
3194 points: *const GpPoint,
3195 count: INT,
3196 ) -> GpStatus;
3197}
3198extern "C" {
3199 #[link_name = "\u{1}GdipFillClosedCurve2"]
3200 pub fn GdipFillClosedCurve2(
3201 graphics: *mut GpGraphics,
3202 brush: *mut GpBrush,
3203 points: *const GpPointF,
3204 count: INT,
3205 tension: REAL,
3206 fillMode: GpFillMode,
3207 ) -> GpStatus;
3208}
3209extern "C" {
3210 #[link_name = "\u{1}GdipFillClosedCurve2I"]
3211 pub fn GdipFillClosedCurve2I(
3212 graphics: *mut GpGraphics,
3213 brush: *mut GpBrush,
3214 points: *const GpPoint,
3215 count: INT,
3216 tension: REAL,
3217 fillMode: GpFillMode,
3218 ) -> GpStatus;
3219}
3220extern "C" {
3221 #[link_name = "\u{1}GdipFillRegion"]
3222 pub fn GdipFillRegion(
3223 graphics: *mut GpGraphics,
3224 brush: *mut GpBrush,
3225 region: *mut GpRegion,
3226 ) -> GpStatus;
3227}
3228extern "C" {
3229 #[link_name = "\u{1}GdipDrawImage"]
3230 pub fn GdipDrawImage(
3231 graphics: *mut GpGraphics,
3232 image: *mut GpImage,
3233 x: REAL,
3234 y: REAL,
3235 ) -> GpStatus;
3236}
3237extern "C" {
3238 #[link_name = "\u{1}GdipDrawImageI"]
3239 pub fn GdipDrawImageI(
3240 graphics: *mut GpGraphics,
3241 image: *mut GpImage,
3242 x: INT,
3243 y: INT,
3244 ) -> GpStatus;
3245}
3246extern "C" {
3247 #[link_name = "\u{1}GdipDrawImageRect"]
3248 pub fn GdipDrawImageRect(
3249 graphics: *mut GpGraphics,
3250 image: *mut GpImage,
3251 x: REAL,
3252 y: REAL,
3253 width: REAL,
3254 height: REAL,
3255 ) -> GpStatus;
3256}
3257extern "C" {
3258 #[link_name = "\u{1}GdipDrawImageRectI"]
3259 pub fn GdipDrawImageRectI(
3260 graphics: *mut GpGraphics,
3261 image: *mut GpImage,
3262 x: INT,
3263 y: INT,
3264 width: INT,
3265 height: INT,
3266 ) -> GpStatus;
3267}
3268extern "C" {
3269 #[link_name = "\u{1}GdipDrawImagePoints"]
3270 pub fn GdipDrawImagePoints(
3271 graphics: *mut GpGraphics,
3272 image: *mut GpImage,
3273 dstpoints: *const GpPointF,
3274 count: INT,
3275 ) -> GpStatus;
3276}
3277extern "C" {
3278 #[link_name = "\u{1}GdipDrawImagePointsI"]
3279 pub fn GdipDrawImagePointsI(
3280 graphics: *mut GpGraphics,
3281 image: *mut GpImage,
3282 dstpoints: *const GpPoint,
3283 count: INT,
3284 ) -> GpStatus;
3285}
3286extern "C" {
3287 #[link_name = "\u{1}GdipDrawImagePointRect"]
3288 pub fn GdipDrawImagePointRect(
3289 graphics: *mut GpGraphics,
3290 image: *mut GpImage,
3291 x: REAL,
3292 y: REAL,
3293 srcx: REAL,
3294 srcy: REAL,
3295 srcwidth: REAL,
3296 srcheight: REAL,
3297 srcUnit: GpUnit,
3298 ) -> GpStatus;
3299}
3300extern "C" {
3301 #[link_name = "\u{1}GdipDrawImagePointRectI"]
3302 pub fn GdipDrawImagePointRectI(
3303 graphics: *mut GpGraphics,
3304 image: *mut GpImage,
3305 x: INT,
3306 y: INT,
3307 srcx: INT,
3308 srcy: INT,
3309 srcwidth: INT,
3310 srcheight: INT,
3311 srcUnit: GpUnit,
3312 ) -> GpStatus;
3313}
3314extern "C" {
3315 #[link_name = "\u{1}GdipDrawImageRectRect"]
3316 pub fn GdipDrawImageRectRect(
3317 graphics: *mut GpGraphics,
3318 image: *mut GpImage,
3319 dstx: REAL,
3320 dsty: REAL,
3321 dstwidth: REAL,
3322 dstheight: REAL,
3323 srcx: REAL,
3324 srcy: REAL,
3325 srcwidth: REAL,
3326 srcheight: REAL,
3327 srcUnit: GpUnit,
3328 imageAttributes: *const GpImageAttributes,
3329 callback: DrawImageAbort,
3330 callbackData: *mut c_void,
3331 ) -> GpStatus;
3332}
3333extern "C" {
3334 #[link_name = "\u{1}GdipDrawImageRectRectI"]
3335 pub fn GdipDrawImageRectRectI(
3336 graphics: *mut GpGraphics,
3337 image: *mut GpImage,
3338 dstx: INT,
3339 dsty: INT,
3340 dstwidth: INT,
3341 dstheight: INT,
3342 srcx: INT,
3343 srcy: INT,
3344 srcwidth: INT,
3345 srcheight: INT,
3346 srcUnit: GpUnit,
3347 imageAttributes: *const GpImageAttributes,
3348 callback: DrawImageAbort,
3349 callbackData: *mut c_void,
3350 ) -> GpStatus;
3351}
3352extern "C" {
3353 #[link_name = "\u{1}GdipDrawImagePointsRect"]
3354 pub fn GdipDrawImagePointsRect(
3355 graphics: *mut GpGraphics,
3356 image: *mut GpImage,
3357 points: *const GpPointF,
3358 count: INT,
3359 srcx: REAL,
3360 srcy: REAL,
3361 srcwidth: REAL,
3362 srcheight: REAL,
3363 srcUnit: GpUnit,
3364 imageAttributes: *const GpImageAttributes,
3365 callback: DrawImageAbort,
3366 callbackData: *mut c_void,
3367 ) -> GpStatus;
3368}
3369extern "C" {
3370 #[link_name = "\u{1}GdipDrawImagePointsRectI"]
3371 pub fn GdipDrawImagePointsRectI(
3372 graphics: *mut GpGraphics,
3373 image: *mut GpImage,
3374 points: *const GpPoint,
3375 count: INT,
3376 srcx: INT,
3377 srcy: INT,
3378 srcwidth: INT,
3379 srcheight: INT,
3380 srcUnit: GpUnit,
3381 imageAttributes: *const GpImageAttributes,
3382 callback: DrawImageAbort,
3383 callbackData: *mut c_void,
3384 ) -> GpStatus;
3385}
3386extern "C" {
3387 #[link_name = "\u{1}GdipEnumerateMetafileDestPoint"]
3388 pub fn GdipEnumerateMetafileDestPoint(
3389 graphics: *mut GpGraphics,
3390 metafile: *const GpMetafile,
3391 destPoint: *const PointF,
3392 callback: EnumerateMetafileProc,
3393 callbackData: *mut c_void,
3394 imageAttributes: *const GpImageAttributes,
3395 ) -> GpStatus;
3396}
3397extern "C" {
3398 #[link_name = "\u{1}GdipEnumerateMetafileDestPointI"]
3399 pub fn GdipEnumerateMetafileDestPointI(
3400 graphics: *mut GpGraphics,
3401 metafile: *const GpMetafile,
3402 destPoint: *const Point,
3403 callback: EnumerateMetafileProc,
3404 callbackData: *mut c_void,
3405 imageAttributes: *const GpImageAttributes,
3406 ) -> GpStatus;
3407}
3408extern "C" {
3409 #[link_name = "\u{1}GdipEnumerateMetafileDestRect"]
3410 pub fn GdipEnumerateMetafileDestRect(
3411 graphics: *mut GpGraphics,
3412 metafile: *const GpMetafile,
3413 destRect: *const RectF,
3414 callback: EnumerateMetafileProc,
3415 callbackData: *mut c_void,
3416 imageAttributes: *const GpImageAttributes,
3417 ) -> GpStatus;
3418}
3419extern "C" {
3420 #[link_name = "\u{1}GdipEnumerateMetafileDestRectI"]
3421 pub fn GdipEnumerateMetafileDestRectI(
3422 graphics: *mut GpGraphics,
3423 metafile: *const GpMetafile,
3424 destRect: *const Rect,
3425 callback: EnumerateMetafileProc,
3426 callbackData: *mut c_void,
3427 imageAttributes: *const GpImageAttributes,
3428 ) -> GpStatus;
3429}
3430extern "C" {
3431 #[link_name = "\u{1}GdipEnumerateMetafileDestPoints"]
3432 pub fn GdipEnumerateMetafileDestPoints(
3433 graphics: *mut GpGraphics,
3434 metafile: *const GpMetafile,
3435 destPoints: *const PointF,
3436 count: INT,
3437 callback: EnumerateMetafileProc,
3438 callbackData: *mut c_void,
3439 imageAttributes: *const GpImageAttributes,
3440 ) -> GpStatus;
3441}
3442extern "C" {
3443 #[link_name = "\u{1}GdipEnumerateMetafileDestPointsI"]
3444 pub fn GdipEnumerateMetafileDestPointsI(
3445 graphics: *mut GpGraphics,
3446 metafile: *const GpMetafile,
3447 destPoints: *const Point,
3448 count: INT,
3449 callback: EnumerateMetafileProc,
3450 callbackData: *mut c_void,
3451 imageAttributes: *const GpImageAttributes,
3452 ) -> GpStatus;
3453}
3454extern "C" {
3455 #[link_name = "\u{1}GdipEnumerateMetafileSrcRectDestPoint"]
3456 pub fn GdipEnumerateMetafileSrcRectDestPoint(
3457 graphics: *mut GpGraphics,
3458 metafile: *const GpMetafile,
3459 destPoint: *const PointF,
3460 srcRect: *const RectF,
3461 srcUnit: Unit,
3462 callback: EnumerateMetafileProc,
3463 callbackData: *mut c_void,
3464 imageAttributes: *const GpImageAttributes,
3465 ) -> GpStatus;
3466}
3467extern "C" {
3468 #[link_name = "\u{1}GdipEnumerateMetafileSrcRectDestPointI"]
3469 pub fn GdipEnumerateMetafileSrcRectDestPointI(
3470 graphics: *mut GpGraphics,
3471 metafile: *const GpMetafile,
3472 destPoint: *const Point,
3473 srcRect: *const Rect,
3474 srcUnit: Unit,
3475 callback: EnumerateMetafileProc,
3476 callbackData: *mut c_void,
3477 imageAttributes: *const GpImageAttributes,
3478 ) -> GpStatus;
3479}
3480extern "C" {
3481 #[link_name = "\u{1}GdipEnumerateMetafileSrcRectDestRect"]
3482 pub fn GdipEnumerateMetafileSrcRectDestRect(
3483 graphics: *mut GpGraphics,
3484 metafile: *const GpMetafile,
3485 destRect: *const RectF,
3486 srcRect: *const RectF,
3487 srcUnit: Unit,
3488 callback: EnumerateMetafileProc,
3489 callbackData: *mut c_void,
3490 imageAttributes: *const GpImageAttributes,
3491 ) -> GpStatus;
3492}
3493extern "C" {
3494 #[link_name = "\u{1}GdipEnumerateMetafileSrcRectDestRectI"]
3495 pub fn GdipEnumerateMetafileSrcRectDestRectI(
3496 graphics: *mut GpGraphics,
3497 metafile: *const GpMetafile,
3498 destRect: *const Rect,
3499 srcRect: *const Rect,
3500 srcUnit: Unit,
3501 callback: EnumerateMetafileProc,
3502 callbackData: *mut c_void,
3503 imageAttributes: *const GpImageAttributes,
3504 ) -> GpStatus;
3505}
3506extern "C" {
3507 #[link_name = "\u{1}GdipEnumerateMetafileSrcRectDestPoints"]
3508 pub fn GdipEnumerateMetafileSrcRectDestPoints(
3509 graphics: *mut GpGraphics,
3510 metafile: *const GpMetafile,
3511 destPoints: *const PointF,
3512 count: INT,
3513 srcRect: *const RectF,
3514 srcUnit: Unit,
3515 callback: EnumerateMetafileProc,
3516 callbackData: *mut c_void,
3517 imageAttributes: *const GpImageAttributes,
3518 ) -> GpStatus;
3519}
3520extern "C" {
3521 #[link_name = "\u{1}GdipEnumerateMetafileSrcRectDestPointsI"]
3522 pub fn GdipEnumerateMetafileSrcRectDestPointsI(
3523 graphics: *mut GpGraphics,
3524 metafile: *const GpMetafile,
3525 destPoints: *const Point,
3526 count: INT,
3527 srcRect: *const Rect,
3528 srcUnit: Unit,
3529 callback: EnumerateMetafileProc,
3530 callbackData: *mut c_void,
3531 imageAttributes: *const GpImageAttributes,
3532 ) -> GpStatus;
3533}
3534extern "C" {
3535 #[link_name = "\u{1}GdipPlayMetafileRecord"]
3536 pub fn GdipPlayMetafileRecord(
3537 metafile: *const GpMetafile,
3538 recordType: EmfPlusRecordType,
3539 flags: UINT,
3540 dataSize: UINT,
3541 data: *const BYTE,
3542 ) -> GpStatus;
3543}
3544extern "C" {
3545 #[link_name = "\u{1}GdipSetClipGraphics"]
3546 pub fn GdipSetClipGraphics(
3547 graphics: *mut GpGraphics,
3548 srcgraphics: *mut GpGraphics,
3549 combineMode: CombineMode,
3550 ) -> GpStatus;
3551}
3552extern "C" {
3553 #[link_name = "\u{1}GdipSetClipRect"]
3554 pub fn GdipSetClipRect(
3555 graphics: *mut GpGraphics,
3556 x: REAL,
3557 y: REAL,
3558 width: REAL,
3559 height: REAL,
3560 combineMode: CombineMode,
3561 ) -> GpStatus;
3562}
3563extern "C" {
3564 #[link_name = "\u{1}GdipSetClipRectI"]
3565 pub fn GdipSetClipRectI(
3566 graphics: *mut GpGraphics,
3567 x: INT,
3568 y: INT,
3569 width: INT,
3570 height: INT,
3571 combineMode: CombineMode,
3572 ) -> GpStatus;
3573}
3574extern "C" {
3575 #[link_name = "\u{1}GdipSetClipPath"]
3576 pub fn GdipSetClipPath(
3577 graphics: *mut GpGraphics,
3578 path: *mut GpPath,
3579 combineMode: CombineMode,
3580 ) -> GpStatus;
3581}
3582extern "C" {
3583 #[link_name = "\u{1}GdipSetClipRegion"]
3584 pub fn GdipSetClipRegion(
3585 graphics: *mut GpGraphics,
3586 region: *mut GpRegion,
3587 combineMode: CombineMode,
3588 ) -> GpStatus;
3589}
3590extern "C" {
3591 #[link_name = "\u{1}GdipSetClipHrgn"]
3592 pub fn GdipSetClipHrgn(
3593 graphics: *mut GpGraphics,
3594 hRgn: HRGN,
3595 combineMode: CombineMode,
3596 ) -> GpStatus;
3597}
3598extern "C" {
3599 #[link_name = "\u{1}GdipResetClip"]
3600 pub fn GdipResetClip(graphics: *mut GpGraphics) -> GpStatus;
3601}
3602extern "C" {
3603 #[link_name = "\u{1}GdipTranslateClip"]
3604 pub fn GdipTranslateClip(graphics: *mut GpGraphics, dx: REAL, dy: REAL) -> GpStatus;
3605}
3606extern "C" {
3607 #[link_name = "\u{1}GdipTranslateClipI"]
3608 pub fn GdipTranslateClipI(graphics: *mut GpGraphics, dx: INT, dy: INT) -> GpStatus;
3609}
3610extern "C" {
3611 #[link_name = "\u{1}GdipGetClip"]
3612 pub fn GdipGetClip(graphics: *mut GpGraphics, region: *mut GpRegion) -> GpStatus;
3613}
3614extern "C" {
3615 #[link_name = "\u{1}GdipGetClipBounds"]
3616 pub fn GdipGetClipBounds(graphics: *mut GpGraphics, rect: *mut GpRectF) -> GpStatus;
3617}
3618extern "C" {
3619 #[link_name = "\u{1}GdipGetClipBoundsI"]
3620 pub fn GdipGetClipBoundsI(graphics: *mut GpGraphics, rect: *mut GpRect) -> GpStatus;
3621}
3622extern "C" {
3623 #[link_name = "\u{1}GdipIsClipEmpty"]
3624 pub fn GdipIsClipEmpty(graphics: *mut GpGraphics, result: *mut BOOL) -> GpStatus;
3625}
3626extern "C" {
3627 #[link_name = "\u{1}GdipGetVisibleClipBounds"]
3628 pub fn GdipGetVisibleClipBounds(graphics: *mut GpGraphics, rect: *mut GpRectF) -> GpStatus;
3629}
3630extern "C" {
3631 #[link_name = "\u{1}GdipGetVisibleClipBoundsI"]
3632 pub fn GdipGetVisibleClipBoundsI(graphics: *mut GpGraphics, rect: *mut GpRect) -> GpStatus;
3633}
3634extern "C" {
3635 #[link_name = "\u{1}GdipIsVisibleClipEmpty"]
3636 pub fn GdipIsVisibleClipEmpty(graphics: *mut GpGraphics, result: *mut BOOL) -> GpStatus;
3637}
3638extern "C" {
3639 #[link_name = "\u{1}GdipIsVisiblePoint"]
3640 pub fn GdipIsVisiblePoint(
3641 graphics: *mut GpGraphics,
3642 x: REAL,
3643 y: REAL,
3644 result: *mut BOOL,
3645 ) -> GpStatus;
3646}
3647extern "C" {
3648 #[link_name = "\u{1}GdipIsVisiblePointI"]
3649 pub fn GdipIsVisiblePointI(
3650 graphics: *mut GpGraphics,
3651 x: INT,
3652 y: INT,
3653 result: *mut BOOL,
3654 ) -> GpStatus;
3655}
3656extern "C" {
3657 #[link_name = "\u{1}GdipIsVisibleRect"]
3658 pub fn GdipIsVisibleRect(
3659 graphics: *mut GpGraphics,
3660 x: REAL,
3661 y: REAL,
3662 width: REAL,
3663 height: REAL,
3664 result: *mut BOOL,
3665 ) -> GpStatus;
3666}
3667extern "C" {
3668 #[link_name = "\u{1}GdipIsVisibleRectI"]
3669 pub fn GdipIsVisibleRectI(
3670 graphics: *mut GpGraphics,
3671 x: INT,
3672 y: INT,
3673 width: INT,
3674 height: INT,
3675 result: *mut BOOL,
3676 ) -> GpStatus;
3677}
3678extern "C" {
3679 #[link_name = "\u{1}GdipSaveGraphics"]
3680 pub fn GdipSaveGraphics(graphics: *mut GpGraphics, state: *mut GraphicsState) -> GpStatus;
3681}
3682extern "C" {
3683 #[link_name = "\u{1}GdipRestoreGraphics"]
3684 pub fn GdipRestoreGraphics(graphics: *mut GpGraphics, state: GraphicsState) -> GpStatus;
3685}
3686extern "C" {
3687 #[link_name = "\u{1}GdipBeginContainer"]
3688 pub fn GdipBeginContainer(
3689 graphics: *mut GpGraphics,
3690 dstrect: *const GpRectF,
3691 srcrect: *const GpRectF,
3692 unit: GpUnit,
3693 state: *mut GraphicsContainer,
3694 ) -> GpStatus;
3695}
3696extern "C" {
3697 #[link_name = "\u{1}GdipBeginContainerI"]
3698 pub fn GdipBeginContainerI(
3699 graphics: *mut GpGraphics,
3700 dstrect: *const GpRect,
3701 srcrect: *const GpRect,
3702 unit: GpUnit,
3703 state: *mut GraphicsContainer,
3704 ) -> GpStatus;
3705}
3706extern "C" {
3707 #[link_name = "\u{1}GdipBeginContainer2"]
3708 pub fn GdipBeginContainer2(
3709 graphics: *mut GpGraphics,
3710 state: *mut GraphicsContainer,
3711 ) -> GpStatus;
3712}
3713extern "C" {
3714 #[link_name = "\u{1}GdipEndContainer"]
3715 pub fn GdipEndContainer(graphics: *mut GpGraphics, state: GraphicsContainer) -> GpStatus;
3716}
3717extern "C" {
3718 #[link_name = "\u{1}GdipGetMetafileHeaderFromWmf"]
3719 pub fn GdipGetMetafileHeaderFromWmf(
3720 hWmf: HMETAFILE,
3721 wmfPlaceableFileHeader: *const WmfPlaceableFileHeader,
3722 header: *mut MetafileHeader,
3723 ) -> GpStatus;
3724}
3725extern "C" {
3726 #[link_name = "\u{1}GdipGetMetafileHeaderFromEmf"]
3727 pub fn GdipGetMetafileHeaderFromEmf(
3728 hEmf: HENHMETAFILE,
3729 header: *mut MetafileHeader,
3730 ) -> GpStatus;
3731}
3732extern "C" {
3733 #[link_name = "\u{1}GdipGetMetafileHeaderFromFile"]
3734 pub fn GdipGetMetafileHeaderFromFile(
3735 filename: *const WCHAR,
3736 header: *mut MetafileHeader,
3737 ) -> GpStatus;
3738}
3739extern "C" {
3740 #[link_name = "\u{1}GdipGetMetafileHeaderFromStream"]
3741 pub fn GdipGetMetafileHeaderFromStream(
3742 stream: *mut IStream,
3743 header: *mut MetafileHeader,
3744 ) -> GpStatus;
3745}
3746extern "C" {
3747 #[link_name = "\u{1}GdipGetMetafileHeaderFromMetafile"]
3748 pub fn GdipGetMetafileHeaderFromMetafile(
3749 metafile: *mut GpMetafile,
3750 header: *mut MetafileHeader,
3751 ) -> GpStatus;
3752}
3753extern "C" {
3754 #[link_name = "\u{1}GdipGetHemfFromMetafile"]
3755 pub fn GdipGetHemfFromMetafile(metafile: *mut GpMetafile, hEmf: *mut HENHMETAFILE) -> GpStatus;
3756}
3757extern "C" {
3758 #[link_name = "\u{1}GdipCreateStreamOnFile"]
3759 pub fn GdipCreateStreamOnFile(
3760 filename: *const WCHAR,
3761 access: UINT,
3762 stream: *mut *mut IStream,
3763 ) -> GpStatus;
3764}
3765extern "C" {
3766 #[link_name = "\u{1}GdipCreateMetafileFromWmf"]
3767 pub fn GdipCreateMetafileFromWmf(
3768 hWmf: HMETAFILE,
3769 deleteWmf: BOOL,
3770 wmfPlaceableFileHeader: *const WmfPlaceableFileHeader,
3771 metafile: *mut *mut GpMetafile,
3772 ) -> GpStatus;
3773}
3774extern "C" {
3775 #[link_name = "\u{1}GdipCreateMetafileFromEmf"]
3776 pub fn GdipCreateMetafileFromEmf(
3777 hEmf: HENHMETAFILE,
3778 deleteEmf: BOOL,
3779 metafile: *mut *mut GpMetafile,
3780 ) -> GpStatus;
3781}
3782extern "C" {
3783 #[link_name = "\u{1}GdipCreateMetafileFromFile"]
3784 pub fn GdipCreateMetafileFromFile(
3785 file: *const WCHAR,
3786 metafile: *mut *mut GpMetafile,
3787 ) -> GpStatus;
3788}
3789extern "C" {
3790 #[link_name = "\u{1}GdipCreateMetafileFromWmfFile"]
3791 pub fn GdipCreateMetafileFromWmfFile(
3792 file: *const WCHAR,
3793 wmfPlaceableFileHeader: *const WmfPlaceableFileHeader,
3794 metafile: *mut *mut GpMetafile,
3795 ) -> GpStatus;
3796}
3797extern "C" {
3798 #[link_name = "\u{1}GdipCreateMetafileFromStream"]
3799 pub fn GdipCreateMetafileFromStream(
3800 stream: *mut IStream,
3801 metafile: *mut *mut GpMetafile,
3802 ) -> GpStatus;
3803}
3804extern "C" {
3805 #[link_name = "\u{1}GdipRecordMetafile"]
3806 pub fn GdipRecordMetafile(
3807 referenceHdc: HDC,
3808 type_: EmfType,
3809 frameRect: *const GpRectF,
3810 frameUnit: MetafileFrameUnit,
3811 description: *const WCHAR,
3812 metafile: *mut *mut GpMetafile,
3813 ) -> GpStatus;
3814}
3815extern "C" {
3816 #[link_name = "\u{1}GdipRecordMetafileI"]
3817 pub fn GdipRecordMetafileI(
3818 referenceHdc: HDC,
3819 type_: EmfType,
3820 frameRect: *const GpRect,
3821 frameUnit: MetafileFrameUnit,
3822 description: *const WCHAR,
3823 metafile: *mut *mut GpMetafile,
3824 ) -> GpStatus;
3825}
3826extern "C" {
3827 #[link_name = "\u{1}GdipRecordMetafileFileName"]
3828 pub fn GdipRecordMetafileFileName(
3829 fileName: *const WCHAR,
3830 referenceHdc: HDC,
3831 type_: EmfType,
3832 frameRect: *const GpRectF,
3833 frameUnit: MetafileFrameUnit,
3834 description: *const WCHAR,
3835 metafile: *mut *mut GpMetafile,
3836 ) -> GpStatus;
3837}
3838extern "C" {
3839 #[link_name = "\u{1}GdipRecordMetafileFileNameI"]
3840 pub fn GdipRecordMetafileFileNameI(
3841 fileName: *const WCHAR,
3842 referenceHdc: HDC,
3843 type_: EmfType,
3844 frameRect: *const GpRect,
3845 frameUnit: MetafileFrameUnit,
3846 description: *const WCHAR,
3847 metafile: *mut *mut GpMetafile,
3848 ) -> GpStatus;
3849}
3850extern "C" {
3851 #[link_name = "\u{1}GdipRecordMetafileStream"]
3852 pub fn GdipRecordMetafileStream(
3853 stream: *mut IStream,
3854 referenceHdc: HDC,
3855 type_: EmfType,
3856 frameRect: *const GpRectF,
3857 frameUnit: MetafileFrameUnit,
3858 description: *const WCHAR,
3859 metafile: *mut *mut GpMetafile,
3860 ) -> GpStatus;
3861}
3862extern "C" {
3863 #[link_name = "\u{1}GdipRecordMetafileStreamI"]
3864 pub fn GdipRecordMetafileStreamI(
3865 stream: *mut IStream,
3866 referenceHdc: HDC,
3867 type_: EmfType,
3868 frameRect: *const GpRect,
3869 frameUnit: MetafileFrameUnit,
3870 description: *const WCHAR,
3871 metafile: *mut *mut GpMetafile,
3872 ) -> GpStatus;
3873}
3874extern "C" {
3875 #[link_name = "\u{1}GdipSetMetafileDownLevelRasterizationLimit"]
3876 pub fn GdipSetMetafileDownLevelRasterizationLimit(
3877 metafile: *mut GpMetafile,
3878 metafileRasterizationLimitDpi: UINT,
3879 ) -> GpStatus;
3880}
3881extern "C" {
3882 #[link_name = "\u{1}GdipGetMetafileDownLevelRasterizationLimit"]
3883 pub fn GdipGetMetafileDownLevelRasterizationLimit(
3884 metafile: *const GpMetafile,
3885 metafileRasterizationLimitDpi: *mut UINT,
3886 ) -> GpStatus;
3887}
3888extern "C" {
3889 #[link_name = "\u{1}GdipGetImageDecodersSize"]
3890 pub fn GdipGetImageDecodersSize(numDecoders: *mut UINT, size: *mut UINT) -> GpStatus;
3891}
3892extern "C" {
3893 #[link_name = "\u{1}GdipGetImageDecoders"]
3894 pub fn GdipGetImageDecoders(
3895 numDecoders: UINT,
3896 size: UINT,
3897 decoders: *mut ImageCodecInfo,
3898 ) -> GpStatus;
3899}
3900extern "C" {
3901 #[link_name = "\u{1}GdipGetImageEncodersSize"]
3902 pub fn GdipGetImageEncodersSize(numEncoders: *mut UINT, size: *mut UINT) -> GpStatus;
3903}
3904extern "C" {
3905 #[link_name = "\u{1}GdipGetImageEncoders"]
3906 pub fn GdipGetImageEncoders(
3907 numEncoders: UINT,
3908 size: UINT,
3909 encoders: *mut ImageCodecInfo,
3910 ) -> GpStatus;
3911}
3912extern "C" {
3913 #[link_name = "\u{1}GdipComment"]
3914 pub fn GdipComment(graphics: *mut GpGraphics, sizeData: UINT, data: *const BYTE) -> GpStatus;
3915}
3916extern "C" {
3917 #[link_name = "\u{1}GdipCreateFontFamilyFromName"]
3918 pub fn GdipCreateFontFamilyFromName(
3919 name: *const WCHAR,
3920 fontCollection: *mut GpFontCollection,
3921 fontFamily: *mut *mut GpFontFamily,
3922 ) -> GpStatus;
3923}
3924extern "C" {
3925 #[link_name = "\u{1}GdipDeleteFontFamily"]
3926 pub fn GdipDeleteFontFamily(fontFamily: *mut GpFontFamily) -> GpStatus;
3927}
3928extern "C" {
3929 #[link_name = "\u{1}GdipCloneFontFamily"]
3930 pub fn GdipCloneFontFamily(
3931 fontFamily: *mut GpFontFamily,
3932 clonedFontFamily: *mut *mut GpFontFamily,
3933 ) -> GpStatus;
3934}
3935extern "C" {
3936 #[link_name = "\u{1}GdipGetGenericFontFamilySansSerif"]
3937 pub fn GdipGetGenericFontFamilySansSerif(nativeFamily: *mut *mut GpFontFamily) -> GpStatus;
3938}
3939extern "C" {
3940 #[link_name = "\u{1}GdipGetGenericFontFamilySerif"]
3941 pub fn GdipGetGenericFontFamilySerif(nativeFamily: *mut *mut GpFontFamily) -> GpStatus;
3942}
3943extern "C" {
3944 #[link_name = "\u{1}GdipGetGenericFontFamilyMonospace"]
3945 pub fn GdipGetGenericFontFamilyMonospace(nativeFamily: *mut *mut GpFontFamily) -> GpStatus;
3946}
3947extern "C" {
3948 #[link_name = "\u{1}GdipGetFamilyName"]
3949 pub fn GdipGetFamilyName(
3950 family: *const GpFontFamily,
3951 name: LPWSTR,
3952 language: LANGID,
3953 ) -> GpStatus;
3954}
3955extern "C" {
3956 #[link_name = "\u{1}GdipIsStyleAvailable"]
3957 pub fn GdipIsStyleAvailable(
3958 family: *const GpFontFamily,
3959 style: INT,
3960 IsStyleAvailable: *mut BOOL,
3961 ) -> GpStatus;
3962}
3963extern "C" {
3964 #[link_name = "\u{1}GdipFontCollectionEnumerable"]
3965 pub fn GdipFontCollectionEnumerable(
3966 fontCollection: *mut GpFontCollection,
3967 graphics: *mut GpGraphics,
3968 numFound: *mut INT,
3969 ) -> GpStatus;
3970}
3971extern "C" {
3972 #[link_name = "\u{1}GdipFontCollectionEnumerate"]
3973 pub fn GdipFontCollectionEnumerate(
3974 fontCollection: *mut GpFontCollection,
3975 numSought: INT,
3976 gpfamilies: *mut *mut GpFontFamily,
3977 numFound: *mut INT,
3978 graphics: *mut GpGraphics,
3979 ) -> GpStatus;
3980}
3981extern "C" {
3982 #[link_name = "\u{1}GdipGetEmHeight"]
3983 pub fn GdipGetEmHeight(
3984 family: *const GpFontFamily,
3985 style: INT,
3986 EmHeight: *mut UINT16,
3987 ) -> GpStatus;
3988}
3989extern "C" {
3990 #[link_name = "\u{1}GdipGetCellAscent"]
3991 pub fn GdipGetCellAscent(
3992 family: *const GpFontFamily,
3993 style: INT,
3994 CellAscent: *mut UINT16,
3995 ) -> GpStatus;
3996}
3997extern "C" {
3998 #[link_name = "\u{1}GdipGetCellDescent"]
3999 pub fn GdipGetCellDescent(
4000 family: *const GpFontFamily,
4001 style: INT,
4002 CellDescent: *mut UINT16,
4003 ) -> GpStatus;
4004}
4005extern "C" {
4006 #[link_name = "\u{1}GdipGetLineSpacing"]
4007 pub fn GdipGetLineSpacing(
4008 family: *const GpFontFamily,
4009 style: INT,
4010 LineSpacing: *mut UINT16,
4011 ) -> GpStatus;
4012}
4013extern "C" {
4014 #[link_name = "\u{1}GdipCreateFontFromDC"]
4015 pub fn GdipCreateFontFromDC(hdc: HDC, font: *mut *mut GpFont) -> GpStatus;
4016}
4017extern "C" {
4018 #[link_name = "\u{1}GdipCreateFontFromLogfontA"]
4019 pub fn GdipCreateFontFromLogfontA(
4020 hdc: HDC,
4021 logfont: *const LOGFONTA,
4022 font: *mut *mut GpFont,
4023 ) -> GpStatus;
4024}
4025extern "C" {
4026 #[link_name = "\u{1}GdipCreateFontFromLogfontW"]
4027 pub fn GdipCreateFontFromLogfontW(
4028 hdc: HDC,
4029 logfont: *const LOGFONTW,
4030 font: *mut *mut GpFont,
4031 ) -> GpStatus;
4032}
4033extern "C" {
4034 #[link_name = "\u{1}GdipCreateFont"]
4035 pub fn GdipCreateFont(
4036 fontFamily: *const GpFontFamily,
4037 emSize: REAL,
4038 style: INT,
4039 unit: Unit,
4040 font: *mut *mut GpFont,
4041 ) -> GpStatus;
4042}
4043extern "C" {
4044 #[link_name = "\u{1}GdipCloneFont"]
4045 pub fn GdipCloneFont(font: *mut GpFont, cloneFont: *mut *mut GpFont) -> GpStatus;
4046}
4047extern "C" {
4048 #[link_name = "\u{1}GdipDeleteFont"]
4049 pub fn GdipDeleteFont(font: *mut GpFont) -> GpStatus;
4050}
4051extern "C" {
4052 #[link_name = "\u{1}GdipGetFamily"]
4053 pub fn GdipGetFamily(font: *mut GpFont, family: *mut *mut GpFontFamily) -> GpStatus;
4054}
4055extern "C" {
4056 #[link_name = "\u{1}GdipGetFontStyle"]
4057 pub fn GdipGetFontStyle(font: *mut GpFont, style: *mut INT) -> GpStatus;
4058}
4059extern "C" {
4060 #[link_name = "\u{1}GdipGetFontSize"]
4061 pub fn GdipGetFontSize(font: *mut GpFont, size: *mut REAL) -> GpStatus;
4062}
4063extern "C" {
4064 #[link_name = "\u{1}GdipGetFontUnit"]
4065 pub fn GdipGetFontUnit(font: *mut GpFont, unit: *mut Unit) -> GpStatus;
4066}
4067extern "C" {
4068 #[link_name = "\u{1}GdipGetFontHeight"]
4069 pub fn GdipGetFontHeight(
4070 font: *const GpFont,
4071 graphics: *const GpGraphics,
4072 height: *mut REAL,
4073 ) -> GpStatus;
4074}
4075extern "C" {
4076 #[link_name = "\u{1}GdipGetFontHeightGivenDPI"]
4077 pub fn GdipGetFontHeightGivenDPI(font: *const GpFont, dpi: REAL, height: *mut REAL)
4078 -> GpStatus;
4079}
4080extern "C" {
4081 #[link_name = "\u{1}GdipGetLogFontA"]
4082 pub fn GdipGetLogFontA(
4083 font: *mut GpFont,
4084 graphics: *mut GpGraphics,
4085 logfontA: *mut LOGFONTA,
4086 ) -> GpStatus;
4087}
4088extern "C" {
4089 #[link_name = "\u{1}GdipGetLogFontW"]
4090 pub fn GdipGetLogFontW(
4091 font: *mut GpFont,
4092 graphics: *mut GpGraphics,
4093 logfontW: *mut LOGFONTW,
4094 ) -> GpStatus;
4095}
4096extern "C" {
4097 #[link_name = "\u{1}GdipNewInstalledFontCollection"]
4098 pub fn GdipNewInstalledFontCollection(fontCollection: *mut *mut GpFontCollection) -> GpStatus;
4099}
4100extern "C" {
4101 #[link_name = "\u{1}GdipNewPrivateFontCollection"]
4102 pub fn GdipNewPrivateFontCollection(fontCollection: *mut *mut GpFontCollection) -> GpStatus;
4103}
4104extern "C" {
4105 #[link_name = "\u{1}GdipDeletePrivateFontCollection"]
4106 pub fn GdipDeletePrivateFontCollection(fontCollection: *mut *mut GpFontCollection) -> GpStatus;
4107}
4108extern "C" {
4109 #[link_name = "\u{1}GdipGetFontCollectionFamilyCount"]
4110 pub fn GdipGetFontCollectionFamilyCount(
4111 fontCollection: *mut GpFontCollection,
4112 numFound: *mut INT,
4113 ) -> GpStatus;
4114}
4115extern "C" {
4116 #[link_name = "\u{1}GdipGetFontCollectionFamilyList"]
4117 pub fn GdipGetFontCollectionFamilyList(
4118 fontCollection: *mut GpFontCollection,
4119 numSought: INT,
4120 gpfamilies: *mut *mut GpFontFamily,
4121 numFound: *mut INT,
4122 ) -> GpStatus;
4123}
4124extern "C" {
4125 #[link_name = "\u{1}GdipPrivateAddFontFile"]
4126 pub fn GdipPrivateAddFontFile(
4127 fontCollection: *mut GpFontCollection,
4128 filename: *const WCHAR,
4129 ) -> GpStatus;
4130}
4131extern "C" {
4132 #[link_name = "\u{1}GdipPrivateAddMemoryFont"]
4133 pub fn GdipPrivateAddMemoryFont(
4134 fontCollection: *mut GpFontCollection,
4135 memory: *const c_void,
4136 length: INT,
4137 ) -> GpStatus;
4138}
4139extern "C" {
4140 #[link_name = "\u{1}GdipDrawString"]
4141 pub fn GdipDrawString(
4142 graphics: *mut GpGraphics,
4143 string: *const WCHAR,
4144 length: INT,
4145 font: *const GpFont,
4146 layoutRect: *const RectF,
4147 stringFormat: *const GpStringFormat,
4148 brush: *const GpBrush,
4149 ) -> GpStatus;
4150}
4151extern "C" {
4152 #[link_name = "\u{1}GdipMeasureString"]
4153 pub fn GdipMeasureString(
4154 graphics: *mut GpGraphics,
4155 string: *const WCHAR,
4156 length: INT,
4157 font: *const GpFont,
4158 layoutRect: *const RectF,
4159 stringFormat: *const GpStringFormat,
4160 boundingBox: *mut RectF,
4161 codepointsFitted: *mut INT,
4162 linesFilled: *mut INT,
4163 ) -> GpStatus;
4164}
4165extern "C" {
4166 #[link_name = "\u{1}GdipMeasureCharacterRanges"]
4167 pub fn GdipMeasureCharacterRanges(
4168 graphics: *mut GpGraphics,
4169 string: *const WCHAR,
4170 length: INT,
4171 font: *const GpFont,
4172 layoutRect: *const RectF,
4173 stringFormat: *const GpStringFormat,
4174 regionCount: INT,
4175 regions: *mut *mut GpRegion,
4176 ) -> GpStatus;
4177}
4178extern "C" {
4179 #[link_name = "\u{1}GdipDrawDriverString"]
4180 pub fn GdipDrawDriverString(
4181 graphics: *mut GpGraphics,
4182 text: *const UINT16,
4183 length: INT,
4184 font: *const GpFont,
4185 brush: *const GpBrush,
4186 positions: *const PointF,
4187 flags: INT,
4188 matrix: *const GpMatrix,
4189 ) -> GpStatus;
4190}
4191extern "C" {
4192 #[link_name = "\u{1}GdipMeasureDriverString"]
4193 pub fn GdipMeasureDriverString(
4194 graphics: *mut GpGraphics,
4195 text: *const UINT16,
4196 length: INT,
4197 font: *const GpFont,
4198 positions: *const PointF,
4199 flags: INT,
4200 matrix: *const GpMatrix,
4201 boundingBox: *mut RectF,
4202 ) -> GpStatus;
4203}
4204extern "C" {
4205 #[link_name = "\u{1}GdipCreateStringFormat"]
4206 pub fn GdipCreateStringFormat(
4207 formatAttributes: INT,
4208 language: LANGID,
4209 format: *mut *mut GpStringFormat,
4210 ) -> GpStatus;
4211}
4212extern "C" {
4213 #[link_name = "\u{1}GdipStringFormatGetGenericDefault"]
4214 pub fn GdipStringFormatGetGenericDefault(format: *mut *mut GpStringFormat) -> GpStatus;
4215}
4216extern "C" {
4217 #[link_name = "\u{1}GdipStringFormatGetGenericTypographic"]
4218 pub fn GdipStringFormatGetGenericTypographic(format: *mut *mut GpStringFormat) -> GpStatus;
4219}
4220extern "C" {
4221 #[link_name = "\u{1}GdipDeleteStringFormat"]
4222 pub fn GdipDeleteStringFormat(format: *mut GpStringFormat) -> GpStatus;
4223}
4224extern "C" {
4225 #[link_name = "\u{1}GdipCloneStringFormat"]
4226 pub fn GdipCloneStringFormat(
4227 format: *const GpStringFormat,
4228 newFormat: *mut *mut GpStringFormat,
4229 ) -> GpStatus;
4230}
4231extern "C" {
4232 #[link_name = "\u{1}GdipSetStringFormatFlags"]
4233 pub fn GdipSetStringFormatFlags(format: *mut GpStringFormat, flags: INT) -> GpStatus;
4234}
4235extern "C" {
4236 #[link_name = "\u{1}GdipGetStringFormatFlags"]
4237 pub fn GdipGetStringFormatFlags(format: *const GpStringFormat, flags: *mut INT) -> GpStatus;
4238}
4239extern "C" {
4240 #[link_name = "\u{1}GdipSetStringFormatAlign"]
4241 pub fn GdipSetStringFormatAlign(
4242 format: *mut GpStringFormat,
4243 align: StringAlignment,
4244 ) -> GpStatus;
4245}
4246extern "C" {
4247 #[link_name = "\u{1}GdipGetStringFormatAlign"]
4248 pub fn GdipGetStringFormatAlign(
4249 format: *const GpStringFormat,
4250 align: *mut StringAlignment,
4251 ) -> GpStatus;
4252}
4253extern "C" {
4254 #[link_name = "\u{1}GdipSetStringFormatLineAlign"]
4255 pub fn GdipSetStringFormatLineAlign(
4256 format: *mut GpStringFormat,
4257 align: StringAlignment,
4258 ) -> GpStatus;
4259}
4260extern "C" {
4261 #[link_name = "\u{1}GdipGetStringFormatLineAlign"]
4262 pub fn GdipGetStringFormatLineAlign(
4263 format: *const GpStringFormat,
4264 align: *mut StringAlignment,
4265 ) -> GpStatus;
4266}
4267extern "C" {
4268 #[link_name = "\u{1}GdipSetStringFormatTrimming"]
4269 pub fn GdipSetStringFormatTrimming(
4270 format: *mut GpStringFormat,
4271 trimming: StringTrimming,
4272 ) -> GpStatus;
4273}
4274extern "C" {
4275 #[link_name = "\u{1}GdipGetStringFormatTrimming"]
4276 pub fn GdipGetStringFormatTrimming(
4277 format: *const GpStringFormat,
4278 trimming: *mut StringTrimming,
4279 ) -> GpStatus;
4280}
4281extern "C" {
4282 #[link_name = "\u{1}GdipSetStringFormatHotkeyPrefix"]
4283 pub fn GdipSetStringFormatHotkeyPrefix(
4284 format: *mut GpStringFormat,
4285 hotkeyPrefix: INT,
4286 ) -> GpStatus;
4287}
4288extern "C" {
4289 #[link_name = "\u{1}GdipGetStringFormatHotkeyPrefix"]
4290 pub fn GdipGetStringFormatHotkeyPrefix(
4291 format: *const GpStringFormat,
4292 hotkeyPrefix: *mut INT,
4293 ) -> GpStatus;
4294}
4295extern "C" {
4296 #[link_name = "\u{1}GdipSetStringFormatTabStops"]
4297 pub fn GdipSetStringFormatTabStops(
4298 format: *mut GpStringFormat,
4299 firstTabOffset: REAL,
4300 count: INT,
4301 tabStops: *const REAL,
4302 ) -> GpStatus;
4303}
4304extern "C" {
4305 #[link_name = "\u{1}GdipGetStringFormatTabStops"]
4306 pub fn GdipGetStringFormatTabStops(
4307 format: *const GpStringFormat,
4308 count: INT,
4309 firstTabOffset: *mut REAL,
4310 tabStops: *mut REAL,
4311 ) -> GpStatus;
4312}
4313extern "C" {
4314 #[link_name = "\u{1}GdipGetStringFormatTabStopCount"]
4315 pub fn GdipGetStringFormatTabStopCount(
4316 format: *const GpStringFormat,
4317 count: *mut INT,
4318 ) -> GpStatus;
4319}
4320extern "C" {
4321 #[link_name = "\u{1}GdipSetStringFormatDigitSubstitution"]
4322 pub fn GdipSetStringFormatDigitSubstitution(
4323 format: *mut GpStringFormat,
4324 language: LANGID,
4325 substitute: StringDigitSubstitute,
4326 ) -> GpStatus;
4327}
4328extern "C" {
4329 #[link_name = "\u{1}GdipGetStringFormatDigitSubstitution"]
4330 pub fn GdipGetStringFormatDigitSubstitution(
4331 format: *const GpStringFormat,
4332 language: *mut LANGID,
4333 substitute: *mut StringDigitSubstitute,
4334 ) -> GpStatus;
4335}
4336extern "C" {
4337 #[link_name = "\u{1}GdipGetStringFormatMeasurableCharacterRangeCount"]
4338 pub fn GdipGetStringFormatMeasurableCharacterRangeCount(
4339 format: *const GpStringFormat,
4340 count: *mut INT,
4341 ) -> GpStatus;
4342}
4343extern "C" {
4344 #[link_name = "\u{1}GdipSetStringFormatMeasurableCharacterRanges"]
4345 pub fn GdipSetStringFormatMeasurableCharacterRanges(
4346 format: *mut GpStringFormat,
4347 rangeCount: INT,
4348 ranges: *const CharacterRange,
4349 ) -> GpStatus;
4350}
4351extern "C" {
4352 #[link_name = "\u{1}GdipCreateCachedBitmap"]
4353 pub fn GdipCreateCachedBitmap(
4354 bitmap: *mut GpBitmap,
4355 graphics: *mut GpGraphics,
4356 cachedBitmap: *mut *mut GpCachedBitmap,
4357 ) -> GpStatus;
4358}
4359extern "C" {
4360 #[link_name = "\u{1}GdipDeleteCachedBitmap"]
4361 pub fn GdipDeleteCachedBitmap(cachedBitmap: *mut GpCachedBitmap) -> GpStatus;
4362}
4363extern "C" {
4364 #[link_name = "\u{1}GdipDrawCachedBitmap"]
4365 pub fn GdipDrawCachedBitmap(
4366 graphics: *mut GpGraphics,
4367 cachedBitmap: *mut GpCachedBitmap,
4368 x: INT,
4369 y: INT,
4370 ) -> GpStatus;
4371}
4372extern "C" {
4373 #[link_name = "\u{1}GdipEmfToWmfBits"]
4374 pub fn GdipEmfToWmfBits(
4375 hemf: HENHMETAFILE,
4376 cbData16: UINT,
4377 pData16: LPBYTE,
4378 iMapMode: INT,
4379 eFlags: INT,
4380 ) -> UINT;
4381}
4382extern "C" {
4383 #[link_name = "\u{1}GdipSetImageAttributesCachedBackground"]
4384 pub fn GdipSetImageAttributesCachedBackground(
4385 imageattr: *mut GpImageAttributes,
4386 enableFlag: BOOL,
4387 ) -> GpStatus;
4388}
4389extern "C" {
4390 #[link_name = "\u{1}GdipTestControl"]
4391 pub fn GdipTestControl(control: GpTestControlEnum, param: *mut c_void) -> GpStatus;
4392}
4393extern "C" {
4394 #[link_name = "\u{1}GdiplusNotificationHook"]
4395 pub fn GdiplusNotificationHook(token: *mut ULONG_PTR) -> GpStatus;
4396}
4397extern "C" {
4398 #[link_name = "\u{1}GdiplusNotificationUnhook"]
4399 pub fn GdiplusNotificationUnhook(token: ULONG_PTR);
4400}
4401#[repr(C)]
4402#[derive(Debug, Copy, Clone)]
4403pub struct GdiplusBase {
4404 pub _address: u8,
4405}
4406pub type GraphicsState = UINT;
4407pub type GraphicsContainer = UINT;
4408pub const FillMode_FillModeAlternate: FillMode = 0;
4409pub const FillMode_FillModeWinding: FillMode = 1;
4410pub type FillMode = c_int;
4411pub const CompositingMode_CompositingModeSourceOver: CompositingMode = 0;
4412pub const CompositingMode_CompositingModeSourceCopy: CompositingMode = 1;
4413pub type CompositingMode = c_int;
4414pub const CompositingQuality_CompositingQualityInvalid: CompositingQuality = -1;
4415pub const CompositingQuality_CompositingQualityDefault: CompositingQuality = 0;
4416pub const CompositingQuality_CompositingQualityHighSpeed: CompositingQuality = 1;
4417pub const CompositingQuality_CompositingQualityHighQuality: CompositingQuality = 2;
4418pub const CompositingQuality_CompositingQualityGammaCorrected: CompositingQuality = 3;
4419pub const CompositingQuality_CompositingQualityAssumeLinear: CompositingQuality = 4;
4420pub type CompositingQuality = c_int;
4421pub const Unit_UnitWorld: Unit = 0;
4422pub const Unit_UnitDisplay: Unit = 1;
4423pub const Unit_UnitPixel: Unit = 2;
4424pub const Unit_UnitPoint: Unit = 3;
4425pub const Unit_UnitInch: Unit = 4;
4426pub const Unit_UnitDocument: Unit = 5;
4427pub const Unit_UnitMillimeter: Unit = 6;
4428pub type Unit = c_int;
4429pub const MetafileFrameUnit_MetafileFrameUnitPixel: MetafileFrameUnit = 2;
4430pub const MetafileFrameUnit_MetafileFrameUnitPoint: MetafileFrameUnit = 3;
4431pub const MetafileFrameUnit_MetafileFrameUnitInch: MetafileFrameUnit = 4;
4432pub const MetafileFrameUnit_MetafileFrameUnitDocument: MetafileFrameUnit = 5;
4433pub const MetafileFrameUnit_MetafileFrameUnitMillimeter: MetafileFrameUnit = 6;
4434pub const MetafileFrameUnit_MetafileFrameUnitGdi: MetafileFrameUnit = 7;
4435pub type MetafileFrameUnit = c_int;
4436pub const CoordinateSpace_CoordinateSpaceWorld: CoordinateSpace = 0;
4437pub const CoordinateSpace_CoordinateSpacePage: CoordinateSpace = 1;
4438pub const CoordinateSpace_CoordinateSpaceDevice: CoordinateSpace = 2;
4439pub type CoordinateSpace = c_int;
4440pub const WrapMode_WrapModeTile: WrapMode = 0;
4441pub const WrapMode_WrapModeTileFlipX: WrapMode = 1;
4442pub const WrapMode_WrapModeTileFlipY: WrapMode = 2;
4443pub const WrapMode_WrapModeTileFlipXY: WrapMode = 3;
4444pub const WrapMode_WrapModeClamp: WrapMode = 4;
4445pub type WrapMode = c_int;
4446pub const HatchStyle_HatchStyleHorizontal: HatchStyle = 0;
4447pub const HatchStyle_HatchStyleVertical: HatchStyle = 1;
4448pub const HatchStyle_HatchStyleForwardDiagonal: HatchStyle = 2;
4449pub const HatchStyle_HatchStyleBackwardDiagonal: HatchStyle = 3;
4450pub const HatchStyle_HatchStyleCross: HatchStyle = 4;
4451pub const HatchStyle_HatchStyleDiagonalCross: HatchStyle = 5;
4452pub const HatchStyle_HatchStyle05Percent: HatchStyle = 6;
4453pub const HatchStyle_HatchStyle10Percent: HatchStyle = 7;
4454pub const HatchStyle_HatchStyle20Percent: HatchStyle = 8;
4455pub const HatchStyle_HatchStyle25Percent: HatchStyle = 9;
4456pub const HatchStyle_HatchStyle30Percent: HatchStyle = 10;
4457pub const HatchStyle_HatchStyle40Percent: HatchStyle = 11;
4458pub const HatchStyle_HatchStyle50Percent: HatchStyle = 12;
4459pub const HatchStyle_HatchStyle60Percent: HatchStyle = 13;
4460pub const HatchStyle_HatchStyle70Percent: HatchStyle = 14;
4461pub const HatchStyle_HatchStyle75Percent: HatchStyle = 15;
4462pub const HatchStyle_HatchStyle80Percent: HatchStyle = 16;
4463pub const HatchStyle_HatchStyle90Percent: HatchStyle = 17;
4464pub const HatchStyle_HatchStyleLightDownwardDiagonal: HatchStyle = 18;
4465pub const HatchStyle_HatchStyleLightUpwardDiagonal: HatchStyle = 19;
4466pub const HatchStyle_HatchStyleDarkDownwardDiagonal: HatchStyle = 20;
4467pub const HatchStyle_HatchStyleDarkUpwardDiagonal: HatchStyle = 21;
4468pub const HatchStyle_HatchStyleWideDownwardDiagonal: HatchStyle = 22;
4469pub const HatchStyle_HatchStyleWideUpwardDiagonal: HatchStyle = 23;
4470pub const HatchStyle_HatchStyleLightVertical: HatchStyle = 24;
4471pub const HatchStyle_HatchStyleLightHorizontal: HatchStyle = 25;
4472pub const HatchStyle_HatchStyleNarrowVertical: HatchStyle = 26;
4473pub const HatchStyle_HatchStyleNarrowHorizontal: HatchStyle = 27;
4474pub const HatchStyle_HatchStyleDarkVertical: HatchStyle = 28;
4475pub const HatchStyle_HatchStyleDarkHorizontal: HatchStyle = 29;
4476pub const HatchStyle_HatchStyleDashedDownwardDiagonal: HatchStyle = 30;
4477pub const HatchStyle_HatchStyleDashedUpwardDiagonal: HatchStyle = 31;
4478pub const HatchStyle_HatchStyleDashedHorizontal: HatchStyle = 32;
4479pub const HatchStyle_HatchStyleDashedVertical: HatchStyle = 33;
4480pub const HatchStyle_HatchStyleSmallConfetti: HatchStyle = 34;
4481pub const HatchStyle_HatchStyleLargeConfetti: HatchStyle = 35;
4482pub const HatchStyle_HatchStyleZigZag: HatchStyle = 36;
4483pub const HatchStyle_HatchStyleWave: HatchStyle = 37;
4484pub const HatchStyle_HatchStyleDiagonalBrick: HatchStyle = 38;
4485pub const HatchStyle_HatchStyleHorizontalBrick: HatchStyle = 39;
4486pub const HatchStyle_HatchStyleWeave: HatchStyle = 40;
4487pub const HatchStyle_HatchStylePlaid: HatchStyle = 41;
4488pub const HatchStyle_HatchStyleDivot: HatchStyle = 42;
4489pub const HatchStyle_HatchStyleDottedGrid: HatchStyle = 43;
4490pub const HatchStyle_HatchStyleDottedDiamond: HatchStyle = 44;
4491pub const HatchStyle_HatchStyleShingle: HatchStyle = 45;
4492pub const HatchStyle_HatchStyleTrellis: HatchStyle = 46;
4493pub const HatchStyle_HatchStyleSphere: HatchStyle = 47;
4494pub const HatchStyle_HatchStyleSmallGrid: HatchStyle = 48;
4495pub const HatchStyle_HatchStyleSmallCheckerBoard: HatchStyle = 49;
4496pub const HatchStyle_HatchStyleLargeCheckerBoard: HatchStyle = 50;
4497pub const HatchStyle_HatchStyleOutlinedDiamond: HatchStyle = 51;
4498pub const HatchStyle_HatchStyleSolidDiamond: HatchStyle = 52;
4499pub const HatchStyle_HatchStyleTotal: HatchStyle = 53;
4500pub const HatchStyle_HatchStyleLargeGrid: HatchStyle = 4;
4501pub const HatchStyle_HatchStyleMin: HatchStyle = 0;
4502pub const HatchStyle_HatchStyleMax: HatchStyle = 52;
4503pub type HatchStyle = c_int;
4504pub const DashStyle_DashStyleSolid: DashStyle = 0;
4505pub const DashStyle_DashStyleDash: DashStyle = 1;
4506pub const DashStyle_DashStyleDot: DashStyle = 2;
4507pub const DashStyle_DashStyleDashDot: DashStyle = 3;
4508pub const DashStyle_DashStyleDashDotDot: DashStyle = 4;
4509pub const DashStyle_DashStyleCustom: DashStyle = 5;
4510pub type DashStyle = c_int;
4511pub const DashCap_DashCapFlat: DashCap = 0;
4512pub const DashCap_DashCapRound: DashCap = 2;
4513pub const DashCap_DashCapTriangle: DashCap = 3;
4514pub type DashCap = c_int;
4515pub const LineCap_LineCapFlat: LineCap = 0;
4516pub const LineCap_LineCapSquare: LineCap = 1;
4517pub const LineCap_LineCapRound: LineCap = 2;
4518pub const LineCap_LineCapTriangle: LineCap = 3;
4519pub const LineCap_LineCapNoAnchor: LineCap = 16;
4520pub const LineCap_LineCapSquareAnchor: LineCap = 17;
4521pub const LineCap_LineCapRoundAnchor: LineCap = 18;
4522pub const LineCap_LineCapDiamondAnchor: LineCap = 19;
4523pub const LineCap_LineCapArrowAnchor: LineCap = 20;
4524pub const LineCap_LineCapCustom: LineCap = 255;
4525pub const LineCap_LineCapAnchorMask: LineCap = 240;
4526pub type LineCap = c_int;
4527pub const CustomLineCapType_CustomLineCapTypeDefault: CustomLineCapType = 0;
4528pub const CustomLineCapType_CustomLineCapTypeAdjustableArrow: CustomLineCapType = 1;
4529pub type CustomLineCapType = c_int;
4530pub const LineJoin_LineJoinMiter: LineJoin = 0;
4531pub const LineJoin_LineJoinBevel: LineJoin = 1;
4532pub const LineJoin_LineJoinRound: LineJoin = 2;
4533pub const LineJoin_LineJoinMiterClipped: LineJoin = 3;
4534pub type LineJoin = c_int;
4535pub const WarpMode_WarpModePerspective: WarpMode = 0;
4536pub const WarpMode_WarpModeBilinear: WarpMode = 1;
4537pub type WarpMode = c_int;
4538pub const LinearGradientMode_LinearGradientModeHorizontal: LinearGradientMode = 0;
4539pub const LinearGradientMode_LinearGradientModeVertical: LinearGradientMode = 1;
4540pub const LinearGradientMode_LinearGradientModeForwardDiagonal: LinearGradientMode = 2;
4541pub const LinearGradientMode_LinearGradientModeBackwardDiagonal: LinearGradientMode = 3;
4542pub type LinearGradientMode = c_int;
4543pub const CombineMode_CombineModeReplace: CombineMode = 0;
4544pub const CombineMode_CombineModeIntersect: CombineMode = 1;
4545pub const CombineMode_CombineModeUnion: CombineMode = 2;
4546pub const CombineMode_CombineModeXor: CombineMode = 3;
4547pub const CombineMode_CombineModeExclude: CombineMode = 4;
4548pub const CombineMode_CombineModeComplement: CombineMode = 5;
4549pub type CombineMode = c_int;
4550pub const ImageType_ImageTypeUnknown: ImageType = 0;
4551pub const ImageType_ImageTypeBitmap: ImageType = 1;
4552pub const ImageType_ImageTypeMetafile: ImageType = 2;
4553pub type ImageType = c_int;
4554pub const InterpolationMode_InterpolationModeInvalid: InterpolationMode = -1;
4555pub const InterpolationMode_InterpolationModeDefault: InterpolationMode = 0;
4556pub const InterpolationMode_InterpolationModeLowQuality: InterpolationMode = 1;
4557pub const InterpolationMode_InterpolationModeHighQuality: InterpolationMode = 2;
4558pub const InterpolationMode_InterpolationModeBilinear: InterpolationMode = 3;
4559pub const InterpolationMode_InterpolationModeBicubic: InterpolationMode = 4;
4560pub const InterpolationMode_InterpolationModeNearestNeighbor: InterpolationMode = 5;
4561pub const InterpolationMode_InterpolationModeHighQualityBilinear: InterpolationMode = 6;
4562pub const InterpolationMode_InterpolationModeHighQualityBicubic: InterpolationMode = 7;
4563pub type InterpolationMode = c_int;
4564pub const PenAlignment_PenAlignmentCenter: PenAlignment = 0;
4565pub const PenAlignment_PenAlignmentInset: PenAlignment = 1;
4566pub type PenAlignment = c_int;
4567pub const BrushType_BrushTypeSolidColor: BrushType = 0;
4568pub const BrushType_BrushTypeHatchFill: BrushType = 1;
4569pub const BrushType_BrushTypeTextureFill: BrushType = 2;
4570pub const BrushType_BrushTypePathGradient: BrushType = 3;
4571pub const BrushType_BrushTypeLinearGradient: BrushType = 4;
4572pub type BrushType = c_int;
4573pub const PenType_PenTypeSolidColor: PenType = 0;
4574pub const PenType_PenTypeHatchFill: PenType = 1;
4575pub const PenType_PenTypeTextureFill: PenType = 2;
4576pub const PenType_PenTypePathGradient: PenType = 3;
4577pub const PenType_PenTypeLinearGradient: PenType = 4;
4578pub const PenType_PenTypeUnknown: PenType = -1;
4579pub type PenType = c_int;
4580pub const MatrixOrder_MatrixOrderPrepend: MatrixOrder = 0;
4581pub const MatrixOrder_MatrixOrderAppend: MatrixOrder = 1;
4582pub type MatrixOrder = c_int;
4583pub const SmoothingMode_SmoothingModeInvalid: SmoothingMode = -1;
4584pub const SmoothingMode_SmoothingModeDefault: SmoothingMode = 0;
4585pub const SmoothingMode_SmoothingModeHighSpeed: SmoothingMode = 1;
4586pub const SmoothingMode_SmoothingModeHighQuality: SmoothingMode = 2;
4587pub const SmoothingMode_SmoothingModeNone: SmoothingMode = 3;
4588pub const SmoothingMode_SmoothingModeAntiAlias: SmoothingMode = 4;
4589pub type SmoothingMode = c_int;
4590pub const PixelOffsetMode_PixelOffsetModeInvalid: PixelOffsetMode = -1;
4591pub const PixelOffsetMode_PixelOffsetModeDefault: PixelOffsetMode = 0;
4592pub const PixelOffsetMode_PixelOffsetModeHighSpeed: PixelOffsetMode = 1;
4593pub const PixelOffsetMode_PixelOffsetModeHighQuality: PixelOffsetMode = 2;
4594pub const PixelOffsetMode_PixelOffsetModeNone: PixelOffsetMode = 3;
4595pub const PixelOffsetMode_PixelOffsetModeHalf: PixelOffsetMode = 4;
4596pub type PixelOffsetMode = c_int;
4597pub const TextRenderingHint_TextRenderingHintSystemDefault: TextRenderingHint = 0;
4598pub const TextRenderingHint_TextRenderingHintSingleBitPerPixelGridFit: TextRenderingHint = 1;
4599pub const TextRenderingHint_TextRenderingHintSingleBitPerPixel: TextRenderingHint = 2;
4600pub const TextRenderingHint_TextRenderingHintAntiAliasGridFit: TextRenderingHint = 3;
4601pub const TextRenderingHint_TextRenderingHintAntiAlias: TextRenderingHint = 4;
4602pub const TextRenderingHint_TextRenderingHintClearTypeGridFit: TextRenderingHint = 5;
4603pub type TextRenderingHint = c_int;
4604pub const MetafileType_MetafileTypeInvalid: MetafileType = 0;
4605pub const MetafileType_MetafileTypeWmf: MetafileType = 1;
4606pub const MetafileType_MetafileTypeWmfPlaceable: MetafileType = 2;
4607pub const MetafileType_MetafileTypeEmf: MetafileType = 3;
4608pub const MetafileType_MetafileTypeEmfPlusOnly: MetafileType = 4;
4609pub const MetafileType_MetafileTypeEmfPlusDual: MetafileType = 5;
4610pub type MetafileType = c_int;
4611pub const EmfType_EmfTypeEmfOnly: EmfType = 3;
4612pub const EmfType_EmfTypeEmfPlusOnly: EmfType = 4;
4613pub const EmfType_EmfTypeEmfPlusDual: EmfType = 5;
4614pub type EmfType = c_int;
4615pub const EmfPlusRecordType_WmfRecordTypeSetBkColor: EmfPlusRecordType = 66049;
4616pub const EmfPlusRecordType_WmfRecordTypeSetBkMode: EmfPlusRecordType = 65794;
4617pub const EmfPlusRecordType_WmfRecordTypeSetMapMode: EmfPlusRecordType = 65795;
4618pub const EmfPlusRecordType_WmfRecordTypeSetROP2: EmfPlusRecordType = 65796;
4619pub const EmfPlusRecordType_WmfRecordTypeSetRelAbs: EmfPlusRecordType = 65797;
4620pub const EmfPlusRecordType_WmfRecordTypeSetPolyFillMode: EmfPlusRecordType = 65798;
4621pub const EmfPlusRecordType_WmfRecordTypeSetStretchBltMode: EmfPlusRecordType = 65799;
4622pub const EmfPlusRecordType_WmfRecordTypeSetTextCharExtra: EmfPlusRecordType = 65800;
4623pub const EmfPlusRecordType_WmfRecordTypeSetTextColor: EmfPlusRecordType = 66057;
4624pub const EmfPlusRecordType_WmfRecordTypeSetTextJustification: EmfPlusRecordType = 66058;
4625pub const EmfPlusRecordType_WmfRecordTypeSetWindowOrg: EmfPlusRecordType = 66059;
4626pub const EmfPlusRecordType_WmfRecordTypeSetWindowExt: EmfPlusRecordType = 66060;
4627pub const EmfPlusRecordType_WmfRecordTypeSetViewportOrg: EmfPlusRecordType = 66061;
4628pub const EmfPlusRecordType_WmfRecordTypeSetViewportExt: EmfPlusRecordType = 66062;
4629pub const EmfPlusRecordType_WmfRecordTypeOffsetWindowOrg: EmfPlusRecordType = 66063;
4630pub const EmfPlusRecordType_WmfRecordTypeScaleWindowExt: EmfPlusRecordType = 66576;
4631pub const EmfPlusRecordType_WmfRecordTypeOffsetViewportOrg: EmfPlusRecordType = 66065;
4632pub const EmfPlusRecordType_WmfRecordTypeScaleViewportExt: EmfPlusRecordType = 66578;
4633pub const EmfPlusRecordType_WmfRecordTypeLineTo: EmfPlusRecordType = 66067;
4634pub const EmfPlusRecordType_WmfRecordTypeMoveTo: EmfPlusRecordType = 66068;
4635pub const EmfPlusRecordType_WmfRecordTypeExcludeClipRect: EmfPlusRecordType = 66581;
4636pub const EmfPlusRecordType_WmfRecordTypeIntersectClipRect: EmfPlusRecordType = 66582;
4637pub const EmfPlusRecordType_WmfRecordTypeArc: EmfPlusRecordType = 67607;
4638pub const EmfPlusRecordType_WmfRecordTypeEllipse: EmfPlusRecordType = 66584;
4639pub const EmfPlusRecordType_WmfRecordTypeFloodFill: EmfPlusRecordType = 66585;
4640pub const EmfPlusRecordType_WmfRecordTypePie: EmfPlusRecordType = 67610;
4641pub const EmfPlusRecordType_WmfRecordTypeRectangle: EmfPlusRecordType = 66587;
4642pub const EmfPlusRecordType_WmfRecordTypeRoundRect: EmfPlusRecordType = 67100;
4643pub const EmfPlusRecordType_WmfRecordTypePatBlt: EmfPlusRecordType = 67101;
4644pub const EmfPlusRecordType_WmfRecordTypeSaveDC: EmfPlusRecordType = 65566;
4645pub const EmfPlusRecordType_WmfRecordTypeSetPixel: EmfPlusRecordType = 66591;
4646pub const EmfPlusRecordType_WmfRecordTypeOffsetClipRgn: EmfPlusRecordType = 66080;
4647pub const EmfPlusRecordType_WmfRecordTypeTextOut: EmfPlusRecordType = 66849;
4648pub const EmfPlusRecordType_WmfRecordTypeBitBlt: EmfPlusRecordType = 67874;
4649pub const EmfPlusRecordType_WmfRecordTypeStretchBlt: EmfPlusRecordType = 68387;
4650pub const EmfPlusRecordType_WmfRecordTypePolygon: EmfPlusRecordType = 66340;
4651pub const EmfPlusRecordType_WmfRecordTypePolyline: EmfPlusRecordType = 66341;
4652pub const EmfPlusRecordType_WmfRecordTypeEscape: EmfPlusRecordType = 67110;
4653pub const EmfPlusRecordType_WmfRecordTypeRestoreDC: EmfPlusRecordType = 65831;
4654pub const EmfPlusRecordType_WmfRecordTypeFillRegion: EmfPlusRecordType = 66088;
4655pub const EmfPlusRecordType_WmfRecordTypeFrameRegion: EmfPlusRecordType = 66601;
4656pub const EmfPlusRecordType_WmfRecordTypeInvertRegion: EmfPlusRecordType = 65834;
4657pub const EmfPlusRecordType_WmfRecordTypePaintRegion: EmfPlusRecordType = 65835;
4658pub const EmfPlusRecordType_WmfRecordTypeSelectClipRegion: EmfPlusRecordType = 65836;
4659pub const EmfPlusRecordType_WmfRecordTypeSelectObject: EmfPlusRecordType = 65837;
4660pub const EmfPlusRecordType_WmfRecordTypeSetTextAlign: EmfPlusRecordType = 65838;
4661pub const EmfPlusRecordType_WmfRecordTypeDrawText: EmfPlusRecordType = 67119;
4662pub const EmfPlusRecordType_WmfRecordTypeChord: EmfPlusRecordType = 67632;
4663pub const EmfPlusRecordType_WmfRecordTypeSetMapperFlags: EmfPlusRecordType = 66097;
4664pub const EmfPlusRecordType_WmfRecordTypeExtTextOut: EmfPlusRecordType = 68146;
4665pub const EmfPlusRecordType_WmfRecordTypeSetDIBToDev: EmfPlusRecordType = 68915;
4666pub const EmfPlusRecordType_WmfRecordTypeSelectPalette: EmfPlusRecordType = 66100;
4667pub const EmfPlusRecordType_WmfRecordTypeRealizePalette: EmfPlusRecordType = 65589;
4668pub const EmfPlusRecordType_WmfRecordTypeAnimatePalette: EmfPlusRecordType = 66614;
4669pub const EmfPlusRecordType_WmfRecordTypeSetPalEntries: EmfPlusRecordType = 65591;
4670pub const EmfPlusRecordType_WmfRecordTypePolyPolygon: EmfPlusRecordType = 66872;
4671pub const EmfPlusRecordType_WmfRecordTypeResizePalette: EmfPlusRecordType = 65849;
4672pub const EmfPlusRecordType_WmfRecordTypeDIBBitBlt: EmfPlusRecordType = 67904;
4673pub const EmfPlusRecordType_WmfRecordTypeDIBStretchBlt: EmfPlusRecordType = 68417;
4674pub const EmfPlusRecordType_WmfRecordTypeDIBCreatePatternBrush: EmfPlusRecordType = 65858;
4675pub const EmfPlusRecordType_WmfRecordTypeStretchDIB: EmfPlusRecordType = 69443;
4676pub const EmfPlusRecordType_WmfRecordTypeExtFloodFill: EmfPlusRecordType = 66888;
4677pub const EmfPlusRecordType_WmfRecordTypeSetLayout: EmfPlusRecordType = 65865;
4678pub const EmfPlusRecordType_WmfRecordTypeResetDC: EmfPlusRecordType = 65868;
4679pub const EmfPlusRecordType_WmfRecordTypeStartDoc: EmfPlusRecordType = 65869;
4680pub const EmfPlusRecordType_WmfRecordTypeStartPage: EmfPlusRecordType = 65615;
4681pub const EmfPlusRecordType_WmfRecordTypeEndPage: EmfPlusRecordType = 65616;
4682pub const EmfPlusRecordType_WmfRecordTypeAbortDoc: EmfPlusRecordType = 65618;
4683pub const EmfPlusRecordType_WmfRecordTypeEndDoc: EmfPlusRecordType = 65630;
4684pub const EmfPlusRecordType_WmfRecordTypeDeleteObject: EmfPlusRecordType = 66032;
4685pub const EmfPlusRecordType_WmfRecordTypeCreatePalette: EmfPlusRecordType = 65783;
4686pub const EmfPlusRecordType_WmfRecordTypeCreateBrush: EmfPlusRecordType = 65784;
4687pub const EmfPlusRecordType_WmfRecordTypeCreatePatternBrush: EmfPlusRecordType = 66041;
4688pub const EmfPlusRecordType_WmfRecordTypeCreatePenIndirect: EmfPlusRecordType = 66298;
4689pub const EmfPlusRecordType_WmfRecordTypeCreateFontIndirect: EmfPlusRecordType = 66299;
4690pub const EmfPlusRecordType_WmfRecordTypeCreateBrushIndirect: EmfPlusRecordType = 66300;
4691pub const EmfPlusRecordType_WmfRecordTypeCreateBitmapIndirect: EmfPlusRecordType = 66301;
4692pub const EmfPlusRecordType_WmfRecordTypeCreateBitmap: EmfPlusRecordType = 67326;
4693pub const EmfPlusRecordType_WmfRecordTypeCreateRegion: EmfPlusRecordType = 67327;
4694pub const EmfPlusRecordType_EmfRecordTypeHeader: EmfPlusRecordType = 1;
4695pub const EmfPlusRecordType_EmfRecordTypePolyBezier: EmfPlusRecordType = 2;
4696pub const EmfPlusRecordType_EmfRecordTypePolygon: EmfPlusRecordType = 3;
4697pub const EmfPlusRecordType_EmfRecordTypePolyline: EmfPlusRecordType = 4;
4698pub const EmfPlusRecordType_EmfRecordTypePolyBezierTo: EmfPlusRecordType = 5;
4699pub const EmfPlusRecordType_EmfRecordTypePolyLineTo: EmfPlusRecordType = 6;
4700pub const EmfPlusRecordType_EmfRecordTypePolyPolyline: EmfPlusRecordType = 7;
4701pub const EmfPlusRecordType_EmfRecordTypePolyPolygon: EmfPlusRecordType = 8;
4702pub const EmfPlusRecordType_EmfRecordTypeSetWindowExtEx: EmfPlusRecordType = 9;
4703pub const EmfPlusRecordType_EmfRecordTypeSetWindowOrgEx: EmfPlusRecordType = 10;
4704pub const EmfPlusRecordType_EmfRecordTypeSetViewportExtEx: EmfPlusRecordType = 11;
4705pub const EmfPlusRecordType_EmfRecordTypeSetViewportOrgEx: EmfPlusRecordType = 12;
4706pub const EmfPlusRecordType_EmfRecordTypeSetBrushOrgEx: EmfPlusRecordType = 13;
4707pub const EmfPlusRecordType_EmfRecordTypeEOF: EmfPlusRecordType = 14;
4708pub const EmfPlusRecordType_EmfRecordTypeSetPixelV: EmfPlusRecordType = 15;
4709pub const EmfPlusRecordType_EmfRecordTypeSetMapperFlags: EmfPlusRecordType = 16;
4710pub const EmfPlusRecordType_EmfRecordTypeSetMapMode: EmfPlusRecordType = 17;
4711pub const EmfPlusRecordType_EmfRecordTypeSetBkMode: EmfPlusRecordType = 18;
4712pub const EmfPlusRecordType_EmfRecordTypeSetPolyFillMode: EmfPlusRecordType = 19;
4713pub const EmfPlusRecordType_EmfRecordTypeSetROP2: EmfPlusRecordType = 20;
4714pub const EmfPlusRecordType_EmfRecordTypeSetStretchBltMode: EmfPlusRecordType = 21;
4715pub const EmfPlusRecordType_EmfRecordTypeSetTextAlign: EmfPlusRecordType = 22;
4716pub const EmfPlusRecordType_EmfRecordTypeSetColorAdjustment: EmfPlusRecordType = 23;
4717pub const EmfPlusRecordType_EmfRecordTypeSetTextColor: EmfPlusRecordType = 24;
4718pub const EmfPlusRecordType_EmfRecordTypeSetBkColor: EmfPlusRecordType = 25;
4719pub const EmfPlusRecordType_EmfRecordTypeOffsetClipRgn: EmfPlusRecordType = 26;
4720pub const EmfPlusRecordType_EmfRecordTypeMoveToEx: EmfPlusRecordType = 27;
4721pub const EmfPlusRecordType_EmfRecordTypeSetMetaRgn: EmfPlusRecordType = 28;
4722pub const EmfPlusRecordType_EmfRecordTypeExcludeClipRect: EmfPlusRecordType = 29;
4723pub const EmfPlusRecordType_EmfRecordTypeIntersectClipRect: EmfPlusRecordType = 30;
4724pub const EmfPlusRecordType_EmfRecordTypeScaleViewportExtEx: EmfPlusRecordType = 31;
4725pub const EmfPlusRecordType_EmfRecordTypeScaleWindowExtEx: EmfPlusRecordType = 32;
4726pub const EmfPlusRecordType_EmfRecordTypeSaveDC: EmfPlusRecordType = 33;
4727pub const EmfPlusRecordType_EmfRecordTypeRestoreDC: EmfPlusRecordType = 34;
4728pub const EmfPlusRecordType_EmfRecordTypeSetWorldTransform: EmfPlusRecordType = 35;
4729pub const EmfPlusRecordType_EmfRecordTypeModifyWorldTransform: EmfPlusRecordType = 36;
4730pub const EmfPlusRecordType_EmfRecordTypeSelectObject: EmfPlusRecordType = 37;
4731pub const EmfPlusRecordType_EmfRecordTypeCreatePen: EmfPlusRecordType = 38;
4732pub const EmfPlusRecordType_EmfRecordTypeCreateBrushIndirect: EmfPlusRecordType = 39;
4733pub const EmfPlusRecordType_EmfRecordTypeDeleteObject: EmfPlusRecordType = 40;
4734pub const EmfPlusRecordType_EmfRecordTypeAngleArc: EmfPlusRecordType = 41;
4735pub const EmfPlusRecordType_EmfRecordTypeEllipse: EmfPlusRecordType = 42;
4736pub const EmfPlusRecordType_EmfRecordTypeRectangle: EmfPlusRecordType = 43;
4737pub const EmfPlusRecordType_EmfRecordTypeRoundRect: EmfPlusRecordType = 44;
4738pub const EmfPlusRecordType_EmfRecordTypeArc: EmfPlusRecordType = 45;
4739pub const EmfPlusRecordType_EmfRecordTypeChord: EmfPlusRecordType = 46;
4740pub const EmfPlusRecordType_EmfRecordTypePie: EmfPlusRecordType = 47;
4741pub const EmfPlusRecordType_EmfRecordTypeSelectPalette: EmfPlusRecordType = 48;
4742pub const EmfPlusRecordType_EmfRecordTypeCreatePalette: EmfPlusRecordType = 49;
4743pub const EmfPlusRecordType_EmfRecordTypeSetPaletteEntries: EmfPlusRecordType = 50;
4744pub const EmfPlusRecordType_EmfRecordTypeResizePalette: EmfPlusRecordType = 51;
4745pub const EmfPlusRecordType_EmfRecordTypeRealizePalette: EmfPlusRecordType = 52;
4746pub const EmfPlusRecordType_EmfRecordTypeExtFloodFill: EmfPlusRecordType = 53;
4747pub const EmfPlusRecordType_EmfRecordTypeLineTo: EmfPlusRecordType = 54;
4748pub const EmfPlusRecordType_EmfRecordTypeArcTo: EmfPlusRecordType = 55;
4749pub const EmfPlusRecordType_EmfRecordTypePolyDraw: EmfPlusRecordType = 56;
4750pub const EmfPlusRecordType_EmfRecordTypeSetArcDirection: EmfPlusRecordType = 57;
4751pub const EmfPlusRecordType_EmfRecordTypeSetMiterLimit: EmfPlusRecordType = 58;
4752pub const EmfPlusRecordType_EmfRecordTypeBeginPath: EmfPlusRecordType = 59;
4753pub const EmfPlusRecordType_EmfRecordTypeEndPath: EmfPlusRecordType = 60;
4754pub const EmfPlusRecordType_EmfRecordTypeCloseFigure: EmfPlusRecordType = 61;
4755pub const EmfPlusRecordType_EmfRecordTypeFillPath: EmfPlusRecordType = 62;
4756pub const EmfPlusRecordType_EmfRecordTypeStrokeAndFillPath: EmfPlusRecordType = 63;
4757pub const EmfPlusRecordType_EmfRecordTypeStrokePath: EmfPlusRecordType = 64;
4758pub const EmfPlusRecordType_EmfRecordTypeFlattenPath: EmfPlusRecordType = 65;
4759pub const EmfPlusRecordType_EmfRecordTypeWidenPath: EmfPlusRecordType = 66;
4760pub const EmfPlusRecordType_EmfRecordTypeSelectClipPath: EmfPlusRecordType = 67;
4761pub const EmfPlusRecordType_EmfRecordTypeAbortPath: EmfPlusRecordType = 68;
4762pub const EmfPlusRecordType_EmfRecordTypeReserved_069: EmfPlusRecordType = 69;
4763pub const EmfPlusRecordType_EmfRecordTypeGdiComment: EmfPlusRecordType = 70;
4764pub const EmfPlusRecordType_EmfRecordTypeFillRgn: EmfPlusRecordType = 71;
4765pub const EmfPlusRecordType_EmfRecordTypeFrameRgn: EmfPlusRecordType = 72;
4766pub const EmfPlusRecordType_EmfRecordTypeInvertRgn: EmfPlusRecordType = 73;
4767pub const EmfPlusRecordType_EmfRecordTypePaintRgn: EmfPlusRecordType = 74;
4768pub const EmfPlusRecordType_EmfRecordTypeExtSelectClipRgn: EmfPlusRecordType = 75;
4769pub const EmfPlusRecordType_EmfRecordTypeBitBlt: EmfPlusRecordType = 76;
4770pub const EmfPlusRecordType_EmfRecordTypeStretchBlt: EmfPlusRecordType = 77;
4771pub const EmfPlusRecordType_EmfRecordTypeMaskBlt: EmfPlusRecordType = 78;
4772pub const EmfPlusRecordType_EmfRecordTypePlgBlt: EmfPlusRecordType = 79;
4773pub const EmfPlusRecordType_EmfRecordTypeSetDIBitsToDevice: EmfPlusRecordType = 80;
4774pub const EmfPlusRecordType_EmfRecordTypeStretchDIBits: EmfPlusRecordType = 81;
4775pub const EmfPlusRecordType_EmfRecordTypeExtCreateFontIndirect: EmfPlusRecordType = 82;
4776pub const EmfPlusRecordType_EmfRecordTypeExtTextOutA: EmfPlusRecordType = 83;
4777pub const EmfPlusRecordType_EmfRecordTypeExtTextOutW: EmfPlusRecordType = 84;
4778pub const EmfPlusRecordType_EmfRecordTypePolyBezier16: EmfPlusRecordType = 85;
4779pub const EmfPlusRecordType_EmfRecordTypePolygon16: EmfPlusRecordType = 86;
4780pub const EmfPlusRecordType_EmfRecordTypePolyline16: EmfPlusRecordType = 87;
4781pub const EmfPlusRecordType_EmfRecordTypePolyBezierTo16: EmfPlusRecordType = 88;
4782pub const EmfPlusRecordType_EmfRecordTypePolylineTo16: EmfPlusRecordType = 89;
4783pub const EmfPlusRecordType_EmfRecordTypePolyPolyline16: EmfPlusRecordType = 90;
4784pub const EmfPlusRecordType_EmfRecordTypePolyPolygon16: EmfPlusRecordType = 91;
4785pub const EmfPlusRecordType_EmfRecordTypePolyDraw16: EmfPlusRecordType = 92;
4786pub const EmfPlusRecordType_EmfRecordTypeCreateMonoBrush: EmfPlusRecordType = 93;
4787pub const EmfPlusRecordType_EmfRecordTypeCreateDIBPatternBrushPt: EmfPlusRecordType = 94;
4788pub const EmfPlusRecordType_EmfRecordTypeExtCreatePen: EmfPlusRecordType = 95;
4789pub const EmfPlusRecordType_EmfRecordTypePolyTextOutA: EmfPlusRecordType = 96;
4790pub const EmfPlusRecordType_EmfRecordTypePolyTextOutW: EmfPlusRecordType = 97;
4791pub const EmfPlusRecordType_EmfRecordTypeSetICMMode: EmfPlusRecordType = 98;
4792pub const EmfPlusRecordType_EmfRecordTypeCreateColorSpace: EmfPlusRecordType = 99;
4793pub const EmfPlusRecordType_EmfRecordTypeSetColorSpace: EmfPlusRecordType = 100;
4794pub const EmfPlusRecordType_EmfRecordTypeDeleteColorSpace: EmfPlusRecordType = 101;
4795pub const EmfPlusRecordType_EmfRecordTypeGLSRecord: EmfPlusRecordType = 102;
4796pub const EmfPlusRecordType_EmfRecordTypeGLSBoundedRecord: EmfPlusRecordType = 103;
4797pub const EmfPlusRecordType_EmfRecordTypePixelFormat: EmfPlusRecordType = 104;
4798pub const EmfPlusRecordType_EmfRecordTypeDrawEscape: EmfPlusRecordType = 105;
4799pub const EmfPlusRecordType_EmfRecordTypeExtEscape: EmfPlusRecordType = 106;
4800pub const EmfPlusRecordType_EmfRecordTypeStartDoc: EmfPlusRecordType = 107;
4801pub const EmfPlusRecordType_EmfRecordTypeSmallTextOut: EmfPlusRecordType = 108;
4802pub const EmfPlusRecordType_EmfRecordTypeForceUFIMapping: EmfPlusRecordType = 109;
4803pub const EmfPlusRecordType_EmfRecordTypeNamedEscape: EmfPlusRecordType = 110;
4804pub const EmfPlusRecordType_EmfRecordTypeColorCorrectPalette: EmfPlusRecordType = 111;
4805pub const EmfPlusRecordType_EmfRecordTypeSetICMProfileA: EmfPlusRecordType = 112;
4806pub const EmfPlusRecordType_EmfRecordTypeSetICMProfileW: EmfPlusRecordType = 113;
4807pub const EmfPlusRecordType_EmfRecordTypeAlphaBlend: EmfPlusRecordType = 114;
4808pub const EmfPlusRecordType_EmfRecordTypeSetLayout: EmfPlusRecordType = 115;
4809pub const EmfPlusRecordType_EmfRecordTypeTransparentBlt: EmfPlusRecordType = 116;
4810pub const EmfPlusRecordType_EmfRecordTypeReserved_117: EmfPlusRecordType = 117;
4811pub const EmfPlusRecordType_EmfRecordTypeGradientFill: EmfPlusRecordType = 118;
4812pub const EmfPlusRecordType_EmfRecordTypeSetLinkedUFIs: EmfPlusRecordType = 119;
4813pub const EmfPlusRecordType_EmfRecordTypeSetTextJustification: EmfPlusRecordType = 120;
4814pub const EmfPlusRecordType_EmfRecordTypeColorMatchToTargetW: EmfPlusRecordType = 121;
4815pub const EmfPlusRecordType_EmfRecordTypeCreateColorSpaceW: EmfPlusRecordType = 122;
4816pub const EmfPlusRecordType_EmfRecordTypeMax: EmfPlusRecordType = 122;
4817pub const EmfPlusRecordType_EmfRecordTypeMin: EmfPlusRecordType = 1;
4818pub const EmfPlusRecordType_EmfPlusRecordTypeInvalid: EmfPlusRecordType = 16384;
4819pub const EmfPlusRecordType_EmfPlusRecordTypeHeader: EmfPlusRecordType = 16385;
4820pub const EmfPlusRecordType_EmfPlusRecordTypeEndOfFile: EmfPlusRecordType = 16386;
4821pub const EmfPlusRecordType_EmfPlusRecordTypeComment: EmfPlusRecordType = 16387;
4822pub const EmfPlusRecordType_EmfPlusRecordTypeGetDC: EmfPlusRecordType = 16388;
4823pub const EmfPlusRecordType_EmfPlusRecordTypeMultiFormatStart: EmfPlusRecordType = 16389;
4824pub const EmfPlusRecordType_EmfPlusRecordTypeMultiFormatSection: EmfPlusRecordType = 16390;
4825pub const EmfPlusRecordType_EmfPlusRecordTypeMultiFormatEnd: EmfPlusRecordType = 16391;
4826pub const EmfPlusRecordType_EmfPlusRecordTypeObject: EmfPlusRecordType = 16392;
4827pub const EmfPlusRecordType_EmfPlusRecordTypeClear: EmfPlusRecordType = 16393;
4828pub const EmfPlusRecordType_EmfPlusRecordTypeFillRects: EmfPlusRecordType = 16394;
4829pub const EmfPlusRecordType_EmfPlusRecordTypeDrawRects: EmfPlusRecordType = 16395;
4830pub const EmfPlusRecordType_EmfPlusRecordTypeFillPolygon: EmfPlusRecordType = 16396;
4831pub const EmfPlusRecordType_EmfPlusRecordTypeDrawLines: EmfPlusRecordType = 16397;
4832pub const EmfPlusRecordType_EmfPlusRecordTypeFillEllipse: EmfPlusRecordType = 16398;
4833pub const EmfPlusRecordType_EmfPlusRecordTypeDrawEllipse: EmfPlusRecordType = 16399;
4834pub const EmfPlusRecordType_EmfPlusRecordTypeFillPie: EmfPlusRecordType = 16400;
4835pub const EmfPlusRecordType_EmfPlusRecordTypeDrawPie: EmfPlusRecordType = 16401;
4836pub const EmfPlusRecordType_EmfPlusRecordTypeDrawArc: EmfPlusRecordType = 16402;
4837pub const EmfPlusRecordType_EmfPlusRecordTypeFillRegion: EmfPlusRecordType = 16403;
4838pub const EmfPlusRecordType_EmfPlusRecordTypeFillPath: EmfPlusRecordType = 16404;
4839pub const EmfPlusRecordType_EmfPlusRecordTypeDrawPath: EmfPlusRecordType = 16405;
4840pub const EmfPlusRecordType_EmfPlusRecordTypeFillClosedCurve: EmfPlusRecordType = 16406;
4841pub const EmfPlusRecordType_EmfPlusRecordTypeDrawClosedCurve: EmfPlusRecordType = 16407;
4842pub const EmfPlusRecordType_EmfPlusRecordTypeDrawCurve: EmfPlusRecordType = 16408;
4843pub const EmfPlusRecordType_EmfPlusRecordTypeDrawBeziers: EmfPlusRecordType = 16409;
4844pub const EmfPlusRecordType_EmfPlusRecordTypeDrawImage: EmfPlusRecordType = 16410;
4845pub const EmfPlusRecordType_EmfPlusRecordTypeDrawImagePoints: EmfPlusRecordType = 16411;
4846pub const EmfPlusRecordType_EmfPlusRecordTypeDrawString: EmfPlusRecordType = 16412;
4847pub const EmfPlusRecordType_EmfPlusRecordTypeSetRenderingOrigin: EmfPlusRecordType = 16413;
4848pub const EmfPlusRecordType_EmfPlusRecordTypeSetAntiAliasMode: EmfPlusRecordType = 16414;
4849pub const EmfPlusRecordType_EmfPlusRecordTypeSetTextRenderingHint: EmfPlusRecordType = 16415;
4850pub const EmfPlusRecordType_EmfPlusRecordTypeSetTextContrast: EmfPlusRecordType = 16416;
4851pub const EmfPlusRecordType_EmfPlusRecordTypeSetInterpolationMode: EmfPlusRecordType = 16417;
4852pub const EmfPlusRecordType_EmfPlusRecordTypeSetPixelOffsetMode: EmfPlusRecordType = 16418;
4853pub const EmfPlusRecordType_EmfPlusRecordTypeSetCompositingMode: EmfPlusRecordType = 16419;
4854pub const EmfPlusRecordType_EmfPlusRecordTypeSetCompositingQuality: EmfPlusRecordType = 16420;
4855pub const EmfPlusRecordType_EmfPlusRecordTypeSave: EmfPlusRecordType = 16421;
4856pub const EmfPlusRecordType_EmfPlusRecordTypeRestore: EmfPlusRecordType = 16422;
4857pub const EmfPlusRecordType_EmfPlusRecordTypeBeginContainer: EmfPlusRecordType = 16423;
4858pub const EmfPlusRecordType_EmfPlusRecordTypeBeginContainerNoParams: EmfPlusRecordType = 16424;
4859pub const EmfPlusRecordType_EmfPlusRecordTypeEndContainer: EmfPlusRecordType = 16425;
4860pub const EmfPlusRecordType_EmfPlusRecordTypeSetWorldTransform: EmfPlusRecordType = 16426;
4861pub const EmfPlusRecordType_EmfPlusRecordTypeResetWorldTransform: EmfPlusRecordType = 16427;
4862pub const EmfPlusRecordType_EmfPlusRecordTypeMultiplyWorldTransform: EmfPlusRecordType = 16428;
4863pub const EmfPlusRecordType_EmfPlusRecordTypeTranslateWorldTransform: EmfPlusRecordType = 16429;
4864pub const EmfPlusRecordType_EmfPlusRecordTypeScaleWorldTransform: EmfPlusRecordType = 16430;
4865pub const EmfPlusRecordType_EmfPlusRecordTypeRotateWorldTransform: EmfPlusRecordType = 16431;
4866pub const EmfPlusRecordType_EmfPlusRecordTypeSetPageTransform: EmfPlusRecordType = 16432;
4867pub const EmfPlusRecordType_EmfPlusRecordTypeResetClip: EmfPlusRecordType = 16433;
4868pub const EmfPlusRecordType_EmfPlusRecordTypeSetClipRect: EmfPlusRecordType = 16434;
4869pub const EmfPlusRecordType_EmfPlusRecordTypeSetClipPath: EmfPlusRecordType = 16435;
4870pub const EmfPlusRecordType_EmfPlusRecordTypeSetClipRegion: EmfPlusRecordType = 16436;
4871pub const EmfPlusRecordType_EmfPlusRecordTypeOffsetClip: EmfPlusRecordType = 16437;
4872pub const EmfPlusRecordType_EmfPlusRecordTypeDrawDriverString: EmfPlusRecordType = 16438;
4873pub const EmfPlusRecordType_EmfPlusRecordTotal: EmfPlusRecordType = 16439;
4874pub const EmfPlusRecordType_EmfPlusRecordTypeMax: EmfPlusRecordType = 16438;
4875pub const EmfPlusRecordType_EmfPlusRecordTypeMin: EmfPlusRecordType = 16385;
4876pub type EmfPlusRecordType = c_int;
4877pub const StringTrimming_StringTrimmingNone: StringTrimming = 0;
4878pub const StringTrimming_StringTrimmingCharacter: StringTrimming = 1;
4879pub const StringTrimming_StringTrimmingWord: StringTrimming = 2;
4880pub const StringTrimming_StringTrimmingEllipsisCharacter: StringTrimming = 3;
4881pub const StringTrimming_StringTrimmingEllipsisWord: StringTrimming = 4;
4882pub const StringTrimming_StringTrimmingEllipsisPath: StringTrimming = 5;
4883pub type StringTrimming = c_int;
4884pub const StringDigitSubstitute_StringDigitSubstituteUser: StringDigitSubstitute = 0;
4885pub const StringDigitSubstitute_StringDigitSubstituteNone: StringDigitSubstitute = 1;
4886pub const StringDigitSubstitute_StringDigitSubstituteNational: StringDigitSubstitute = 2;
4887pub const StringDigitSubstitute_StringDigitSubstituteTraditional: StringDigitSubstitute = 3;
4888pub type StringDigitSubstitute = c_int;
4889pub const StringAlignment_StringAlignmentNear: StringAlignment = 0;
4890pub const StringAlignment_StringAlignmentCenter: StringAlignment = 1;
4891pub const StringAlignment_StringAlignmentFar: StringAlignment = 2;
4892pub type StringAlignment = c_int;
4893pub const FlushIntention_FlushIntentionFlush: FlushIntention = 0;
4894pub const FlushIntention_FlushIntentionSync: FlushIntention = 1;
4895pub type FlushIntention = c_int;
4896pub const GpTestControlEnum_TestControlForceBilinear: GpTestControlEnum = 0;
4897pub const GpTestControlEnum_TestControlNoICM: GpTestControlEnum = 1;
4898pub const GpTestControlEnum_TestControlGetBuildNumber: GpTestControlEnum = 2;
4899pub type GpTestControlEnum = c_int;
4900pub type ImageAbort = Option<unsafe extern "C" fn(arg1: *mut c_void) -> BOOL>;
4901pub type DrawImageAbort = ImageAbort;
4902pub type GetThumbnailImageAbort = ImageAbort;
4903pub type EnumerateMetafileProc = Option<
4904 unsafe extern "C" fn(
4905 arg1: EmfPlusRecordType,
4906 arg2: UINT,
4907 arg3: UINT,
4908 arg4: *const BYTE,
4909 arg5: *mut c_void,
4910 ) -> BOOL,
4911>;
4912pub type REAL = f32;
4913pub const Status_Ok: Status = 0;
4914pub const Status_GenericError: Status = 1;
4915pub const Status_InvalidParameter: Status = 2;
4916pub const Status_OutOfMemory: Status = 3;
4917pub const Status_ObjectBusy: Status = 4;
4918pub const Status_InsufficientBuffer: Status = 5;
4919pub const Status_NotImplemented: Status = 6;
4920pub const Status_Win32Error: Status = 7;
4921pub const Status_WrongState: Status = 8;
4922pub const Status_Aborted: Status = 9;
4923pub const Status_FileNotFound: Status = 10;
4924pub const Status_ValueOverflow: Status = 11;
4925pub const Status_AccessDenied: Status = 12;
4926pub const Status_UnknownImageFormat: Status = 13;
4927pub const Status_FontFamilyNotFound: Status = 14;
4928pub const Status_FontStyleNotFound: Status = 15;
4929pub const Status_NotTrueTypeFont: Status = 16;
4930pub const Status_UnsupportedGdiplusVersion: Status = 17;
4931pub const Status_GdiplusNotInitialized: Status = 18;
4932pub const Status_PropertyNotFound: Status = 19;
4933pub const Status_PropertyNotSupported: Status = 20;
4934pub type Status = c_int;
4935#[repr(C)]
4936#[derive(Debug, Copy, Clone)]
4937pub struct SizeF {
4938 pub Width: REAL,
4939 pub Height: REAL,
4940}
4941#[repr(C)]
4942#[derive(Debug, Copy, Clone)]
4943pub struct PointF {
4944 pub X: REAL,
4945 pub Y: REAL,
4946}
4947#[repr(C)]
4948#[derive(Debug, Copy, Clone)]
4949pub struct Point {
4950 pub X: INT,
4951 pub Y: INT,
4952}
4953#[repr(C)]
4954#[derive(Debug, Copy, Clone)]
4955pub struct RectF {
4956 pub X: REAL,
4957 pub Y: REAL,
4958 pub Width: REAL,
4959 pub Height: REAL,
4960}
4961#[repr(C)]
4962#[derive(Debug, Copy, Clone)]
4963pub struct Rect {
4964 pub X: INT,
4965 pub Y: INT,
4966 pub Width: INT,
4967 pub Height: INT,
4968}
4969#[repr(C)]
4970#[derive(Debug)]
4971pub struct PathData {
4972 pub Count: INT,
4973 pub Points: *mut PointF,
4974 pub Types: *mut BYTE,
4975}
4976#[repr(C)]
4977#[derive(Debug, Copy, Clone)]
4978pub struct CharacterRange {
4979 pub First: INT,
4980 pub Length: INT,
4981}
4982pub const DebugEventLevel_DebugEventLevelFatal: DebugEventLevel = 0;
4983pub const DebugEventLevel_DebugEventLevelWarning: DebugEventLevel = 1;
4984pub type DebugEventLevel = c_int;
4985pub type DebugEventProc = Option<unsafe extern "C" fn(level: DebugEventLevel, message: *mut CHAR)>;
4986pub type NotificationHookProc = Option<unsafe extern "C" fn(token: *mut ULONG_PTR) -> Status>;
4987pub type NotificationUnhookProc = Option<unsafe extern "C" fn(token: ULONG_PTR)>;
4988#[repr(C)]
4989#[derive(Debug, Copy, Clone)]
4990pub struct GdiplusStartupInput {
4991 pub GdiplusVersion: UINT32,
4992 pub DebugEventCallback: DebugEventProc,
4993 pub SuppressBackgroundThread: BOOL,
4994 pub SuppressExternalCodecs: BOOL,
4995}
4996#[repr(C)]
4997#[derive(Debug, Copy, Clone)]
4998pub struct GdiplusStartupOutput {
4999 pub NotificationHook: NotificationHookProc,
5000 pub NotificationUnhook: NotificationUnhookProc,
5001}
5002extern "C" {
5003 #[link_name = "\u{1}GdiplusStartup"]
5004 pub fn GdiplusStartup(
5005 token: *mut ULONG_PTR,
5006 input: *const GdiplusStartupInput,
5007 output: *mut GdiplusStartupOutput,
5008 ) -> Status;
5009}
5010extern "C" {
5011 #[link_name = "\u{1}GdiplusShutdown"]
5012 pub fn GdiplusShutdown(token: ULONG_PTR);
5013}
5014pub type ARGB = DWORD;
5015pub type PixelFormat = INT;
5016#[repr(C)]
5017#[derive(Debug, Copy, Clone)]
5018pub struct ColorPalette {
5019 pub Flags: UINT,
5020 pub Count: UINT,
5021 pub Entries: [ARGB; 1usize],
5022}
5023pub const ColorChannelFlags_ColorChannelFlagsC: ColorChannelFlags = 0;
5024pub const ColorChannelFlags_ColorChannelFlagsM: ColorChannelFlags = 1;
5025pub const ColorChannelFlags_ColorChannelFlagsY: ColorChannelFlags = 2;
5026pub const ColorChannelFlags_ColorChannelFlagsK: ColorChannelFlags = 3;
5027pub const ColorChannelFlags_ColorChannelFlagsLast: ColorChannelFlags = 4;
5028pub type ColorChannelFlags = c_int;
5029#[repr(C)]
5030#[derive(Debug, Copy, Clone)]
5031pub struct Color {
5032 pub Argb: ARGB,
5033}
5034pub const Color_AliceBlue: c_int = -984833;
5035pub const Color_AntiqueWhite: c_int = -332841;
5036pub const Color_Aqua: c_int = -16711681;
5037pub const Color_Aquamarine: c_int = -8388652;
5038pub const Color_Azure: c_int = -983041;
5039pub const Color_Beige: c_int = -657956;
5040pub const Color_Bisque: c_int = -6972;
5041pub const Color_Black: c_int = -16777216;
5042pub const Color_BlanchedAlmond: c_int = -5171;
5043pub const Color_Blue: c_int = -16776961;
5044pub const Color_BlueViolet: c_int = -7722014;
5045pub const Color_Brown: c_int = -5952982;
5046pub const Color_BurlyWood: c_int = -2180985;
5047pub const Color_CadetBlue: c_int = -10510688;
5048pub const Color_Chartreuse: c_int = -8388864;
5049pub const Color_Chocolate: c_int = -2987746;
5050pub const Color_Coral: c_int = -32944;
5051pub const Color_CornflowerBlue: c_int = -10185235;
5052pub const Color_Cornsilk: c_int = -1828;
5053pub const Color_Crimson: c_int = -2354116;
5054pub const Color_Cyan: c_int = -16711681;
5055pub const Color_DarkBlue: c_int = -16777077;
5056pub const Color_DarkCyan: c_int = -16741493;
5057pub const Color_DarkGoldenrod: c_int = -4684277;
5058pub const Color_DarkGray: c_int = -5658199;
5059pub const Color_DarkGreen: c_int = -16751616;
5060pub const Color_DarkKhaki: c_int = -4343957;
5061pub const Color_DarkMagenta: c_int = -7667573;
5062pub const Color_DarkOliveGreen: c_int = -11179217;
5063pub const Color_DarkOrange: c_int = -29696;
5064pub const Color_DarkOrchid: c_int = -6737204;
5065pub const Color_DarkRed: c_int = -7667712;
5066pub const Color_DarkSalmon: c_int = -1468806;
5067pub const Color_DarkSeaGreen: c_int = -7357301;
5068pub const Color_DarkSlateBlue: c_int = -12042869;
5069pub const Color_DarkSlateGray: c_int = -13676721;
5070pub const Color_DarkTurquoise: c_int = -16724271;
5071pub const Color_DarkViolet: c_int = -7077677;
5072pub const Color_DeepPink: c_int = -60269;
5073pub const Color_DeepSkyBlue: c_int = -16728065;
5074pub const Color_DimGray: c_int = -9868951;
5075pub const Color_DodgerBlue: c_int = -14774017;
5076pub const Color_Firebrick: c_int = -5103070;
5077pub const Color_FloralWhite: c_int = -1296;
5078pub const Color_ForestGreen: c_int = -14513374;
5079pub const Color_Fuchsia: c_int = -65281;
5080pub const Color_Gainsboro: c_int = -2302756;
5081pub const Color_GhostWhite: c_int = -460545;
5082pub const Color_Gold: c_int = -10496;
5083pub const Color_Goldenrod: c_int = -2448096;
5084pub const Color_Gray: c_int = -8355712;
5085pub const Color_Green: c_int = -16744448;
5086pub const Color_GreenYellow: c_int = -5374161;
5087pub const Color_Honeydew: c_int = -983056;
5088pub const Color_HotPink: c_int = -38476;
5089pub const Color_IndianRed: c_int = -3318692;
5090pub const Color_Indigo: c_int = -11861886;
5091pub const Color_Ivory: c_int = -16;
5092pub const Color_Khaki: c_int = -989556;
5093pub const Color_Lavender: c_int = -1644806;
5094pub const Color_LavenderBlush: c_int = -3851;
5095pub const Color_LawnGreen: c_int = -8586240;
5096pub const Color_LemonChiffon: c_int = -1331;
5097pub const Color_LightBlue: c_int = -5383962;
5098pub const Color_LightCoral: c_int = -1015680;
5099pub const Color_LightCyan: c_int = -2031617;
5100pub const Color_LightGoldenrodYellow: c_int = -329006;
5101pub const Color_LightGray: c_int = -2894893;
5102pub const Color_LightGreen: c_int = -7278960;
5103pub const Color_LightPink: c_int = -18751;
5104pub const Color_LightSalmon: c_int = -24454;
5105pub const Color_LightSeaGreen: c_int = -14634326;
5106pub const Color_LightSkyBlue: c_int = -7876870;
5107pub const Color_LightSlateGray: c_int = -8943463;
5108pub const Color_LightSteelBlue: c_int = -5192482;
5109pub const Color_LightYellow: c_int = -32;
5110pub const Color_Lime: c_int = -16711936;
5111pub const Color_LimeGreen: c_int = -13447886;
5112pub const Color_Linen: c_int = -331546;
5113pub const Color_Magenta: c_int = -65281;
5114pub const Color_Maroon: c_int = -8388608;
5115pub const Color_MediumAquamarine: c_int = -10039894;
5116pub const Color_MediumBlue: c_int = -16777011;
5117pub const Color_MediumOrchid: c_int = -4565549;
5118pub const Color_MediumPurple: c_int = -7114533;
5119pub const Color_MediumSeaGreen: c_int = -12799119;
5120pub const Color_MediumSlateBlue: c_int = -8689426;
5121pub const Color_MediumSpringGreen: c_int = -16713062;
5122pub const Color_MediumTurquoise: c_int = -12004916;
5123pub const Color_MediumVioletRed: c_int = -3730043;
5124pub const Color_MidnightBlue: c_int = -15132304;
5125pub const Color_MintCream: c_int = -655366;
5126pub const Color_MistyRose: c_int = -6943;
5127pub const Color_Moccasin: c_int = -6987;
5128pub const Color_NavajoWhite: c_int = -8531;
5129pub const Color_Navy: c_int = -16777088;
5130pub const Color_OldLace: c_int = -133658;
5131pub const Color_Olive: c_int = -8355840;
5132pub const Color_OliveDrab: c_int = -9728477;
5133pub const Color_Orange: c_int = -23296;
5134pub const Color_OrangeRed: c_int = -47872;
5135pub const Color_Orchid: c_int = -2461482;
5136pub const Color_PaleGoldenrod: c_int = -1120086;
5137pub const Color_PaleGreen: c_int = -6751336;
5138pub const Color_PaleTurquoise: c_int = -5247250;
5139pub const Color_PaleVioletRed: c_int = -2396013;
5140pub const Color_PapayaWhip: c_int = -4139;
5141pub const Color_PeachPuff: c_int = -9543;
5142pub const Color_Peru: c_int = -3308225;
5143pub const Color_Pink: c_int = -16181;
5144pub const Color_Plum: c_int = -2252579;
5145pub const Color_PowderBlue: c_int = -5185306;
5146pub const Color_Purple: c_int = -8388480;
5147pub const Color_Red: c_int = -65536;
5148pub const Color_RosyBrown: c_int = -4419697;
5149pub const Color_RoyalBlue: c_int = -12490271;
5150pub const Color_SaddleBrown: c_int = -7650029;
5151pub const Color_Salmon: c_int = -360334;
5152pub const Color_SandyBrown: c_int = -744352;
5153pub const Color_SeaGreen: c_int = -13726889;
5154pub const Color_SeaShell: c_int = -2578;
5155pub const Color_Sienna: c_int = -6270419;
5156pub const Color_Silver: c_int = -4144960;
5157pub const Color_SkyBlue: c_int = -7876885;
5158pub const Color_SlateBlue: c_int = -9807155;
5159pub const Color_SlateGray: c_int = -9404272;
5160pub const Color_Snow: c_int = -1286;
5161pub const Color_SpringGreen: c_int = -16711809;
5162pub const Color_SteelBlue: c_int = -12156236;
5163pub const Color_Tan: c_int = -2968436;
5164pub const Color_Teal: c_int = -16744320;
5165pub const Color_Thistle: c_int = -2572328;
5166pub const Color_Tomato: c_int = -40121;
5167pub const Color_Transparent: c_int = 16777215;
5168pub const Color_Turquoise: c_int = -12525360;
5169pub const Color_Violet: c_int = -1146130;
5170pub const Color_Wheat: c_int = -663885;
5171pub const Color_White: c_int = -1;
5172pub const Color_WhiteSmoke: c_int = -657931;
5173pub const Color_Yellow: c_int = -256;
5174pub const Color_YellowGreen: c_int = -6632142;
5175pub type Color__bindgen_ty_1 = c_int;
5176pub const Color_AlphaShift: c_int = 24;
5177pub const Color_RedShift: c_int = 16;
5178pub const Color_GreenShift: c_int = 8;
5179pub const Color_BlueShift: c_int = 0;
5180pub type Color__bindgen_ty_2 = c_int;
5181pub const Color_AlphaMask: c_int = -16777216;
5182pub const Color_RedMask: c_int = 16711680;
5183pub const Color_GreenMask: c_int = 65280;
5184pub const Color_BlueMask: c_int = 255;
5185pub type Color__bindgen_ty_3 = c_int;
5186#[repr(C)]
5187#[derive(Copy, Clone)]
5188pub struct ENHMETAHEADER3 {
5189 pub iType: DWORD,
5190 pub nSize: DWORD,
5191 pub rclBounds: RECTL,
5192 pub rclFrame: RECTL,
5193 pub dSignature: DWORD,
5194 pub nVersion: DWORD,
5195 pub nBytes: DWORD,
5196 pub nRecords: DWORD,
5197 pub nHandles: WORD,
5198 pub sReserved: WORD,
5199 pub nDescription: DWORD,
5200 pub offDescription: DWORD,
5201 pub nPalEntries: DWORD,
5202 pub szlDevice: SIZEL,
5203 pub szlMillimeters: SIZEL,
5204}
5205#[repr(C)]
5206#[derive(Debug, Copy, Clone)]
5207pub struct PWMFRect16 {
5208 pub Left: INT16,
5209 pub Top: INT16,
5210 pub Right: INT16,
5211 pub Bottom: INT16,
5212}
5213#[repr(C, packed(2))]
5214#[derive(Debug, Copy, Clone)]
5215pub struct WmfPlaceableFileHeader {
5216 pub Key: UINT32,
5217 pub Hmf: INT16,
5218 pub BoundingBox: PWMFRect16,
5219 pub Inch: INT16,
5220 pub Reserved: UINT32,
5221 pub Checksum: INT16,
5222}
5223#[repr(C)]
5224#[derive(Copy, Clone)]
5225pub struct MetafileHeader {
5226 pub Type: MetafileType,
5227 pub Size: UINT,
5228 pub Version: UINT,
5229 pub EmfPlusFlags: UINT,
5230 pub DpiX: REAL,
5231 pub DpiY: REAL,
5232 pub X: INT,
5233 pub Y: INT,
5234 pub Width: INT,
5235 pub Height: INT,
5236 pub __bindgen_anon_1: MetafileHeader__bindgen_ty_1,
5237 pub EmfPlusHeaderSize: INT,
5238 pub LogicalDpiX: INT,
5239 pub LogicalDpiY: INT,
5240}
5241#[repr(C)]
5242#[derive(Copy, Clone)]
5243pub union MetafileHeader__bindgen_ty_1 {
5244 pub WmfHeader: METAHEADER,
5245 pub EmfHeader: ENHMETAHEADER3,
5246}
5247#[repr(C)]
5248#[derive(Copy, Clone)]
5249pub struct ImageCodecInfo {
5250 pub Clsid: CLSID,
5251 pub FormatID: GUID,
5252 pub CodecName: *const WCHAR,
5253 pub DllName: *const WCHAR,
5254 pub FormatDescription: *const WCHAR,
5255 pub FilenameExtension: *const WCHAR,
5256 pub MimeType: *const WCHAR,
5257 pub Flags: DWORD,
5258 pub Version: DWORD,
5259 pub SigCount: DWORD,
5260 pub SigSize: DWORD,
5261 pub SigPattern: *const BYTE,
5262 pub SigMask: *const BYTE,
5263}
5264#[repr(C)]
5265#[derive(Debug, Copy, Clone)]
5266pub struct BitmapData {
5267 pub Width: UINT,
5268 pub Height: UINT,
5269 pub Stride: INT,
5270 pub PixelFormat: PixelFormat,
5271 pub Scan0: *mut c_void,
5272 pub Reserved: UINT_PTR,
5273}
5274pub const RotateFlipType_RotateNoneFlipNone: RotateFlipType = 0;
5275pub const RotateFlipType_Rotate90FlipNone: RotateFlipType = 1;
5276pub const RotateFlipType_Rotate180FlipNone: RotateFlipType = 2;
5277pub const RotateFlipType_Rotate270FlipNone: RotateFlipType = 3;
5278pub const RotateFlipType_RotateNoneFlipX: RotateFlipType = 4;
5279pub const RotateFlipType_Rotate90FlipX: RotateFlipType = 5;
5280pub const RotateFlipType_Rotate180FlipX: RotateFlipType = 6;
5281pub const RotateFlipType_Rotate270FlipX: RotateFlipType = 7;
5282pub const RotateFlipType_RotateNoneFlipY: RotateFlipType = 6;
5283pub const RotateFlipType_Rotate90FlipY: RotateFlipType = 7;
5284pub const RotateFlipType_Rotate180FlipY: RotateFlipType = 4;
5285pub const RotateFlipType_Rotate270FlipY: RotateFlipType = 5;
5286pub const RotateFlipType_RotateNoneFlipXY: RotateFlipType = 2;
5287pub const RotateFlipType_Rotate90FlipXY: RotateFlipType = 3;
5288pub const RotateFlipType_Rotate180FlipXY: RotateFlipType = 0;
5289pub const RotateFlipType_Rotate270FlipXY: RotateFlipType = 1;
5290pub type RotateFlipType = c_int;
5291#[repr(C)]
5292#[derive(Copy, Clone)]
5293pub struct EncoderParameter {
5294 pub Guid: GUID,
5295 pub NumberOfValues: ULONG,
5296 pub Type: ULONG,
5297 pub Value: *mut c_void,
5298}
5299#[repr(C)]
5300#[derive(Copy, Clone)]
5301pub struct EncoderParameters {
5302 pub Count: UINT,
5303 pub Parameter: [EncoderParameter; 1usize],
5304}
5305#[repr(C)]
5306#[derive(Debug, Copy, Clone)]
5307pub struct PropertyItem {
5308 pub id: PROPID,
5309 pub length: ULONG,
5310 pub type_: WORD,
5311 pub value: *mut c_void,
5312}
5313#[repr(C)]
5314#[derive(Debug, Copy, Clone)]
5315pub struct ColorMatrix {
5316 pub m: [[REAL; 5usize]; 5usize],
5317}
5318pub const ColorMatrixFlags_ColorMatrixFlagsDefault: ColorMatrixFlags = 0;
5319pub const ColorMatrixFlags_ColorMatrixFlagsSkipGrays: ColorMatrixFlags = 1;
5320pub const ColorMatrixFlags_ColorMatrixFlagsAltGray: ColorMatrixFlags = 2;
5321pub type ColorMatrixFlags = c_int;
5322pub const ColorAdjustType_ColorAdjustTypeDefault: ColorAdjustType = 0;
5323pub const ColorAdjustType_ColorAdjustTypeBitmap: ColorAdjustType = 1;
5324pub const ColorAdjustType_ColorAdjustTypeBrush: ColorAdjustType = 2;
5325pub const ColorAdjustType_ColorAdjustTypePen: ColorAdjustType = 3;
5326pub const ColorAdjustType_ColorAdjustTypeText: ColorAdjustType = 4;
5327pub const ColorAdjustType_ColorAdjustTypeCount: ColorAdjustType = 5;
5328pub const ColorAdjustType_ColorAdjustTypeAny: ColorAdjustType = 6;
5329pub type ColorAdjustType = c_int;
5330#[repr(C)]
5331#[derive(Debug, Copy, Clone)]
5332pub struct ColorMap {
5333 pub oldColor: Color,
5334 pub newColor: Color,
5335}
5336#[repr(C)]
5337#[derive(Debug, Copy, Clone)]
5338pub struct GpGraphics {
5339 pub _address: u8,
5340}
5341#[repr(C)]
5342#[derive(Debug, Copy, Clone)]
5343pub struct GpBrush {
5344 pub _address: u8,
5345}
5346#[repr(C)]
5347#[derive(Debug, Copy, Clone)]
5348pub struct GpTexture {
5349 pub _address: u8,
5350}
5351#[repr(C)]
5352#[derive(Debug, Copy, Clone)]
5353pub struct GpSolidFill {
5354 pub _address: u8,
5355}
5356#[repr(C)]
5357#[derive(Debug, Copy, Clone)]
5358pub struct GpLineGradient {
5359 pub _address: u8,
5360}
5361#[repr(C)]
5362#[derive(Debug, Copy, Clone)]
5363pub struct GpPathGradient {
5364 pub _address: u8,
5365}
5366#[repr(C)]
5367#[derive(Debug, Copy, Clone)]
5368pub struct GpHatch {
5369 pub _address: u8,
5370}
5371#[repr(C)]
5372#[derive(Debug, Copy, Clone)]
5373pub struct GpPen {
5374 pub _address: u8,
5375}
5376#[repr(C)]
5377#[derive(Debug, Copy, Clone)]
5378pub struct GpCustomLineCap {
5379 pub _address: u8,
5380}
5381#[repr(C)]
5382#[derive(Debug, Copy, Clone)]
5383pub struct GpAdjustableArrowCap {
5384 pub _address: u8,
5385}
5386#[repr(C)]
5387#[derive(Debug, Copy, Clone)]
5388pub struct GpImage {
5389 pub _address: u8,
5390}
5391#[repr(C)]
5392#[derive(Debug, Copy, Clone)]
5393pub struct GpBitmap {
5394 pub _address: u8,
5395}
5396#[repr(C)]
5397#[derive(Debug, Copy, Clone)]
5398pub struct GpMetafile {
5399 pub _address: u8,
5400}
5401#[repr(C)]
5402#[derive(Debug, Copy, Clone)]
5403pub struct GpImageAttributes {
5404 pub _address: u8,
5405}
5406#[repr(C)]
5407#[derive(Debug, Copy, Clone)]
5408pub struct GpPath {
5409 pub _address: u8,
5410}
5411#[repr(C)]
5412#[derive(Debug, Copy, Clone)]
5413pub struct GpRegion {
5414 pub _address: u8,
5415}
5416#[repr(C)]
5417#[derive(Debug, Copy, Clone)]
5418pub struct GpPathIterator {
5419 pub _address: u8,
5420}
5421#[repr(C)]
5422#[derive(Debug, Copy, Clone)]
5423pub struct GpFontFamily {
5424 pub _address: u8,
5425}
5426#[repr(C)]
5427#[derive(Debug, Copy, Clone)]
5428pub struct GpFont {
5429 pub _address: u8,
5430}
5431#[repr(C)]
5432#[derive(Debug, Copy, Clone)]
5433pub struct GpStringFormat {
5434 pub _address: u8,
5435}
5436#[repr(C)]
5437#[derive(Debug, Copy, Clone)]
5438pub struct GpFontCollection {
5439 pub _address: u8,
5440}
5441#[repr(C)]
5442#[derive(Debug, Copy, Clone)]
5443pub struct GpCachedBitmap {
5444 _unused: [u8; 0],
5445}
5446pub use self::{
5447 CoordinateSpace as GpCoordinateSpace, FillMode as GpFillMode, Status as GpStatus,
5448 Unit as GpUnit, WrapMode as GpWrapMode,
5449};
5450pub type GpPointF = PointF;
5451pub type GpPoint = Point;
5452pub type GpRectF = RectF;
5453pub type GpRect = Rect;
5454pub use self::{
5455 DashCap as GpDashCap, DashStyle as GpDashStyle, HatchStyle as GpHatchStyle,
5456 LineCap as GpLineCap, LineJoin as GpLineJoin, PenAlignment as GpPenAlignment,
5457 PenType as GpPenType,
5458};
5459pub type GpMatrix = Matrix;
5460pub use self::{
5461 BrushType as GpBrushType, FlushIntention as GpFlushIntention, MatrixOrder as GpMatrixOrder,
5462};
5463pub type GpPathData = PathData;
5464#[repr(C)]
5465#[derive(Debug)]
5466pub struct Region {
5467 pub nativeRegion: *mut GpRegion,
5468 pub lastResult: Status,
5469}
5470extern "C" {
5471 #[link_name = "\u{1}?FromHRGN@Region@Gdiplus@@SAPEAV12@PEAUHRGN__@@@Z"]
5472 pub fn Region_FromHRGN(hRgn: HRGN) -> *mut Region;
5473}
5474extern "C" {
5475 #[link_name = "\u{1}?Clone@Region@Gdiplus@@QEBAPEAV12@XZ"]
5476 pub fn Region_Clone(this: *const Region) -> *mut Region;
5477}
5478extern "C" {
5479 #[link_name = "\u{1}?MakeInfinite@Region@Gdiplus@@QEAA?AW4Status@2@XZ"]
5480 pub fn Region_MakeInfinite(this: *mut Region) -> Status;
5481}
5482extern "C" {
5483 #[link_name = "\u{1}?MakeEmpty@Region@Gdiplus@@QEAA?AW4Status@2@XZ"]
5484 pub fn Region_MakeEmpty(this: *mut Region) -> Status;
5485}
5486extern "C" {
5487 #[link_name = "\u{1}?GetDataSize@Region@Gdiplus@@QEBAIXZ"]
5488 pub fn Region_GetDataSize(this: *const Region) -> UINT;
5489}
5490extern "C" {
5491 #[link_name = "\u{1}?GetData@Region@Gdiplus@@QEBA?AW4Status@2@PEAEIPEAI@Z"]
5492 pub fn Region_GetData(
5493 this: *const Region,
5494 buffer: *mut BYTE,
5495 bufferSize: UINT,
5496 sizeFilled: *mut UINT,
5497 ) -> Status;
5498}
5499extern "C" {
5500 #[link_name = "\u{1}?Intersect@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRect@2@@Z"]
5501 pub fn Region_Intersect(this: *mut Region, rect: *const Rect) -> Status;
5502}
5503extern "C" {
5504 #[link_name = "\u{1}?Intersect@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRectF@2@@Z"]
5505 pub fn Region_Intersect1(this: *mut Region, rect: *const RectF) -> Status;
5506}
5507extern "C" {
5508 #[link_name = "\u{1}?Intersect@Region@Gdiplus@@QEAA?AW4Status@2@PEBVGraphicsPath@2@@Z"]
5509 pub fn Region_Intersect2(this: *mut Region, path: *const GraphicsPath) -> Status;
5510}
5511extern "C" {
5512 #[link_name = "\u{1}?Intersect@Region@Gdiplus@@QEAA?AW4Status@2@PEBV12@@Z"]
5513 pub fn Region_Intersect3(this: *mut Region, region: *const Region) -> Status;
5514}
5515extern "C" {
5516 #[link_name = "\u{1}?Union@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRect@2@@Z"]
5517 pub fn Region_Union(this: *mut Region, rect: *const Rect) -> Status;
5518}
5519extern "C" {
5520 #[link_name = "\u{1}?Union@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRectF@2@@Z"]
5521 pub fn Region_Union1(this: *mut Region, rect: *const RectF) -> Status;
5522}
5523extern "C" {
5524 #[link_name = "\u{1}?Union@Region@Gdiplus@@QEAA?AW4Status@2@PEBVGraphicsPath@2@@Z"]
5525 pub fn Region_Union2(this: *mut Region, path: *const GraphicsPath) -> Status;
5526}
5527extern "C" {
5528 #[link_name = "\u{1}?Union@Region@Gdiplus@@QEAA?AW4Status@2@PEBV12@@Z"]
5529 pub fn Region_Union3(this: *mut Region, region: *const Region) -> Status;
5530}
5531extern "C" {
5532 #[link_name = "\u{1}?Xor@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRect@2@@Z"]
5533 pub fn Region_Xor(this: *mut Region, rect: *const Rect) -> Status;
5534}
5535extern "C" {
5536 #[link_name = "\u{1}?Xor@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRectF@2@@Z"]
5537 pub fn Region_Xor1(this: *mut Region, rect: *const RectF) -> Status;
5538}
5539extern "C" {
5540 #[link_name = "\u{1}?Xor@Region@Gdiplus@@QEAA?AW4Status@2@PEBVGraphicsPath@2@@Z"]
5541 pub fn Region_Xor2(this: *mut Region, path: *const GraphicsPath) -> Status;
5542}
5543extern "C" {
5544 #[link_name = "\u{1}?Xor@Region@Gdiplus@@QEAA?AW4Status@2@PEBV12@@Z"]
5545 pub fn Region_Xor3(this: *mut Region, region: *const Region) -> Status;
5546}
5547extern "C" {
5548 #[link_name = "\u{1}?Exclude@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRect@2@@Z"]
5549 pub fn Region_Exclude(this: *mut Region, rect: *const Rect) -> Status;
5550}
5551extern "C" {
5552 #[link_name = "\u{1}?Exclude@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRectF@2@@Z"]
5553 pub fn Region_Exclude1(this: *mut Region, rect: *const RectF) -> Status;
5554}
5555extern "C" {
5556 #[link_name = "\u{1}?Exclude@Region@Gdiplus@@QEAA?AW4Status@2@PEBVGraphicsPath@2@@Z"]
5557 pub fn Region_Exclude2(this: *mut Region, path: *const GraphicsPath) -> Status;
5558}
5559extern "C" {
5560 #[link_name = "\u{1}?Exclude@Region@Gdiplus@@QEAA?AW4Status@2@PEBV12@@Z"]
5561 pub fn Region_Exclude3(this: *mut Region, region: *const Region) -> Status;
5562}
5563extern "C" {
5564 #[link_name = "\u{1}?Complement@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRect@2@@Z"]
5565 pub fn Region_Complement(this: *mut Region, rect: *const Rect) -> Status;
5566}
5567extern "C" {
5568 #[link_name = "\u{1}?Complement@Region@Gdiplus@@QEAA?AW4Status@2@AEBVRectF@2@@Z"]
5569 pub fn Region_Complement1(this: *mut Region, rect: *const RectF) -> Status;
5570}
5571extern "C" {
5572 #[link_name = "\u{1}?Complement@Region@Gdiplus@@QEAA?AW4Status@2@PEBVGraphicsPath@2@@Z"]
5573 pub fn Region_Complement2(this: *mut Region, path: *const GraphicsPath) -> Status;
5574}
5575extern "C" {
5576 #[link_name = "\u{1}?Complement@Region@Gdiplus@@QEAA?AW4Status@2@PEBV12@@Z"]
5577 pub fn Region_Complement3(this: *mut Region, region: *const Region) -> Status;
5578}
5579extern "C" {
5580 #[link_name = "\u{1}?Translate@Region@Gdiplus@@QEAA?AW4Status@2@MM@Z"]
5581 pub fn Region_Translate(this: *mut Region, dx: REAL, dy: REAL) -> Status;
5582}
5583extern "C" {
5584 #[link_name = "\u{1}?Translate@Region@Gdiplus@@QEAA?AW4Status@2@HH@Z"]
5585 pub fn Region_Translate1(this: *mut Region, dx: INT, dy: INT) -> Status;
5586}
5587extern "C" {
5588 #[link_name = "\u{1}?Transform@Region@Gdiplus@@QEAA?AW4Status@2@PEBVMatrix@2@@Z"]
5589 pub fn Region_Transform(this: *mut Region, matrix: *const Matrix) -> Status;
5590}
5591extern "C" {
5592 #[link_name = "\u{1}?GetBounds@Region@Gdiplus@@QEBA?AW4Status@2@PEAVRect@2@PEBVGraphics@2@@Z"]
5593 pub fn Region_GetBounds(this: *const Region, rect: *mut Rect, g: *const Graphics) -> Status;
5594}
5595extern "C" {
5596 #[link_name = "\u{1}?GetBounds@Region@Gdiplus@@QEBA?AW4Status@2@PEAVRectF@2@PEBVGraphics@2@@Z"]
5597 pub fn Region_GetBounds1(this: *const Region, rect: *mut RectF, g: *const Graphics) -> Status;
5598}
5599extern "C" {
5600 #[link_name = "\u{1}?GetHRGN@Region@Gdiplus@@QEBAPEAUHRGN__@@PEBVGraphics@2@@Z"]
5601 pub fn Region_GetHRGN(this: *const Region, g: *const Graphics) -> HRGN;
5602}
5603extern "C" {
5604 #[link_name = "\u{1}?IsEmpty@Region@Gdiplus@@QEBAHPEBVGraphics@2@@Z"]
5605 pub fn Region_IsEmpty(this: *const Region, g: *const Graphics) -> BOOL;
5606}
5607extern "C" {
5608 #[link_name = "\u{1}?IsInfinite@Region@Gdiplus@@QEBAHPEBVGraphics@2@@Z"]
5609 pub fn Region_IsInfinite(this: *const Region, g: *const Graphics) -> BOOL;
5610}
5611extern "C" {
5612 #[link_name = "\u{1}?IsVisible@Region@Gdiplus@@QEBAHAEBVPoint@2@PEBVGraphics@2@@Z"]
5613 pub fn Region_IsVisible(this: *const Region, point: *const Point, g: *const Graphics) -> BOOL;
5614}
5615extern "C" {
5616 #[link_name = "\u{1}?IsVisible@Region@Gdiplus@@QEBAHAEBVPointF@2@PEBVGraphics@2@@Z"]
5617 pub fn Region_IsVisible1(this: *const Region, point: *const PointF, g: *const Graphics)
5618 -> BOOL;
5619}
5620extern "C" {
5621 #[link_name = "\u{1}?IsVisible@Region@Gdiplus@@QEBAHAEBVRect@2@PEBVGraphics@2@@Z"]
5622 pub fn Region_IsVisible2(this: *const Region, rect: *const Rect, g: *const Graphics) -> BOOL;
5623}
5624extern "C" {
5625 #[link_name = "\u{1}?IsVisible@Region@Gdiplus@@QEBAHAEBVRectF@2@PEBVGraphics@2@@Z"]
5626 pub fn Region_IsVisible3(this: *const Region, rect: *const RectF, g: *const Graphics) -> BOOL;
5627}
5628extern "C" {
5629 #[link_name = "\u{1}?Equals@Region@Gdiplus@@QEBAHPEBV12@PEBVGraphics@2@@Z"]
5630 pub fn Region_Equals(this: *const Region, region: *const Region, g: *const Graphics) -> BOOL;
5631}
5632extern "C" {
5633 #[link_name = "\u{1}?GetRegionScansCount@Region@Gdiplus@@QEBAIPEBVMatrix@2@@Z"]
5634 pub fn Region_GetRegionScansCount(this: *const Region, matrix: *const Matrix) -> UINT;
5635}
5636extern "C" {
5637 #[link_name = "\u{1}?GetRegionScans@Region@Gdiplus@@QEBA?AW4Status@2@PEBVMatrix@2@PEAVRectF@2@PEAH@Z"]
5638 pub fn Region_GetRegionScans(
5639 this: *const Region,
5640 matrix: *const Matrix,
5641 rects: *mut RectF,
5642 count: *mut INT,
5643 ) -> Status;
5644}
5645extern "C" {
5646 #[link_name = "\u{1}?GetRegionScans@Region@Gdiplus@@QEBA?AW4Status@2@PEBVMatrix@2@PEAVRect@2@PEAH@Z"]
5647 pub fn Region_GetRegionScans1(
5648 this: *const Region,
5649 matrix: *const Matrix,
5650 rects: *mut Rect,
5651 count: *mut INT,
5652 ) -> Status;
5653}
5654extern "C" {
5655 #[link_name = "\u{1}?GetLastStatus@Region@Gdiplus@@QEBA?AW4Status@2@XZ"]
5656 pub fn Region_GetLastStatus(this: *const Region) -> Status;
5657}
5658extern "C" {
5659 #[link_name = "\u{1}?SetNativeRegion@Region@Gdiplus@@IEAAXPEAVGpRegion@2@@Z"]
5660 pub fn Region_SetNativeRegion(this: *mut Region, nativeRegion: *mut GpRegion);
5661}
5662extern "C" {
5663 #[link_name = "\u{1}??0Region@Gdiplus@@QEAA@XZ"]
5664 pub fn Region_Region(this: *mut Region);
5665}
5666extern "C" {
5667 #[link_name = "\u{1}??0Region@Gdiplus@@QEAA@AEBVRectF@1@@Z"]
5668 pub fn Region_Region1(this: *mut Region, rect: *const RectF);
5669}
5670extern "C" {
5671 #[link_name = "\u{1}??0Region@Gdiplus@@QEAA@AEBVRect@1@@Z"]
5672 pub fn Region_Region2(this: *mut Region, rect: *const Rect);
5673}
5674extern "C" {
5675 #[link_name = "\u{1}??0Region@Gdiplus@@QEAA@PEBVGraphicsPath@1@@Z"]
5676 pub fn Region_Region3(this: *mut Region, path: *const GraphicsPath);
5677}
5678extern "C" {
5679 #[link_name = "\u{1}??0Region@Gdiplus@@QEAA@PEBEH@Z"]
5680 pub fn Region_Region4(this: *mut Region, regionData: *const BYTE, size: INT);
5681}
5682extern "C" {
5683 #[link_name = "\u{1}??0Region@Gdiplus@@QEAA@PEAUHRGN__@@@Z"]
5684 pub fn Region_Region5(this: *mut Region, hRgn: HRGN);
5685}
5686extern "C" {
5687 #[link_name = "\u{1}??0Region@Gdiplus@@IEAA@PEAVGpRegion@1@@Z"]
5688 pub fn Region_Region6(this: *mut Region, nativeRegion: *mut GpRegion);
5689}
5690extern "C" {
5691 #[link_name = "\u{1}??_DRegion@Gdiplus@@QEAAXXZ"]
5692 pub fn Region_Region_destructor(this: *mut Region);
5693}
5694impl Region {
5695 #[inline]
5696 pub unsafe fn FromHRGN(hRgn: HRGN) -> *mut Region {
5697 Region_FromHRGN(hRgn)
5698 }
5699 #[inline]
5700 pub unsafe fn Clone(&self) -> *mut Region {
5701 Region_Clone(self)
5702 }
5703 #[inline]
5704 pub unsafe fn MakeInfinite(&mut self) -> Status {
5705 Region_MakeInfinite(self)
5706 }
5707 #[inline]
5708 pub unsafe fn MakeEmpty(&mut self) -> Status {
5709 Region_MakeEmpty(self)
5710 }
5711 #[inline]
5712 pub unsafe fn GetDataSize(&self) -> UINT {
5713 Region_GetDataSize(self)
5714 }
5715 #[inline]
5716 pub unsafe fn GetData(
5717 &self,
5718 buffer: *mut BYTE,
5719 bufferSize: UINT,
5720 sizeFilled: *mut UINT,
5721 ) -> Status {
5722 Region_GetData(self, buffer, bufferSize, sizeFilled)
5723 }
5724 #[inline]
5725 pub unsafe fn Intersect(&mut self, rect: *const Rect) -> Status {
5726 Region_Intersect(self, rect)
5727 }
5728 #[inline]
5729 pub unsafe fn Intersect1(&mut self, rect: *const RectF) -> Status {
5730 Region_Intersect1(self, rect)
5731 }
5732 #[inline]
5733 pub unsafe fn Intersect2(&mut self, path: *const GraphicsPath) -> Status {
5734 Region_Intersect2(self, path)
5735 }
5736 #[inline]
5737 pub unsafe fn Intersect3(&mut self, region: *const Region) -> Status {
5738 Region_Intersect3(self, region)
5739 }
5740 #[inline]
5741 pub unsafe fn Union(&mut self, rect: *const Rect) -> Status {
5742 Region_Union(self, rect)
5743 }
5744 #[inline]
5745 pub unsafe fn Union1(&mut self, rect: *const RectF) -> Status {
5746 Region_Union1(self, rect)
5747 }
5748 #[inline]
5749 pub unsafe fn Union2(&mut self, path: *const GraphicsPath) -> Status {
5750 Region_Union2(self, path)
5751 }
5752 #[inline]
5753 pub unsafe fn Union3(&mut self, region: *const Region) -> Status {
5754 Region_Union3(self, region)
5755 }
5756 #[inline]
5757 pub unsafe fn Xor(&mut self, rect: *const Rect) -> Status {
5758 Region_Xor(self, rect)
5759 }
5760 #[inline]
5761 pub unsafe fn Xor1(&mut self, rect: *const RectF) -> Status {
5762 Region_Xor1(self, rect)
5763 }
5764 #[inline]
5765 pub unsafe fn Xor2(&mut self, path: *const GraphicsPath) -> Status {
5766 Region_Xor2(self, path)
5767 }
5768 #[inline]
5769 pub unsafe fn Xor3(&mut self, region: *const Region) -> Status {
5770 Region_Xor3(self, region)
5771 }
5772 #[inline]
5773 pub unsafe fn Exclude(&mut self, rect: *const Rect) -> Status {
5774 Region_Exclude(self, rect)
5775 }
5776 #[inline]
5777 pub unsafe fn Exclude1(&mut self, rect: *const RectF) -> Status {
5778 Region_Exclude1(self, rect)
5779 }
5780 #[inline]
5781 pub unsafe fn Exclude2(&mut self, path: *const GraphicsPath) -> Status {
5782 Region_Exclude2(self, path)
5783 }
5784 #[inline]
5785 pub unsafe fn Exclude3(&mut self, region: *const Region) -> Status {
5786 Region_Exclude3(self, region)
5787 }
5788 #[inline]
5789 pub unsafe fn Complement(&mut self, rect: *const Rect) -> Status {
5790 Region_Complement(self, rect)
5791 }
5792 #[inline]
5793 pub unsafe fn Complement1(&mut self, rect: *const RectF) -> Status {
5794 Region_Complement1(self, rect)
5795 }
5796 #[inline]
5797 pub unsafe fn Complement2(&mut self, path: *const GraphicsPath) -> Status {
5798 Region_Complement2(self, path)
5799 }
5800 #[inline]
5801 pub unsafe fn Complement3(&mut self, region: *const Region) -> Status {
5802 Region_Complement3(self, region)
5803 }
5804 #[inline]
5805 pub unsafe fn Translate(&mut self, dx: REAL, dy: REAL) -> Status {
5806 Region_Translate(self, dx, dy)
5807 }
5808 #[inline]
5809 pub unsafe fn Translate1(&mut self, dx: INT, dy: INT) -> Status {
5810 Region_Translate1(self, dx, dy)
5811 }
5812 #[inline]
5813 pub unsafe fn Transform(&mut self, matrix: *const Matrix) -> Status {
5814 Region_Transform(self, matrix)
5815 }
5816 #[inline]
5817 pub unsafe fn GetBounds(&self, rect: *mut Rect, g: *const Graphics) -> Status {
5818 Region_GetBounds(self, rect, g)
5819 }
5820 #[inline]
5821 pub unsafe fn GetBounds1(&self, rect: *mut RectF, g: *const Graphics) -> Status {
5822 Region_GetBounds1(self, rect, g)
5823 }
5824 #[inline]
5825 pub unsafe fn GetHRGN(&self, g: *const Graphics) -> HRGN {
5826 Region_GetHRGN(self, g)
5827 }
5828 #[inline]
5829 pub unsafe fn IsEmpty(&self, g: *const Graphics) -> BOOL {
5830 Region_IsEmpty(self, g)
5831 }
5832 #[inline]
5833 pub unsafe fn IsInfinite(&self, g: *const Graphics) -> BOOL {
5834 Region_IsInfinite(self, g)
5835 }
5836 #[inline]
5837 pub unsafe fn IsVisible(&self, point: *const Point, g: *const Graphics) -> BOOL {
5838 Region_IsVisible(self, point, g)
5839 }
5840 #[inline]
5841 pub unsafe fn IsVisible1(&self, point: *const PointF, g: *const Graphics) -> BOOL {
5842 Region_IsVisible1(self, point, g)
5843 }
5844 #[inline]
5845 pub unsafe fn IsVisible2(&self, rect: *const Rect, g: *const Graphics) -> BOOL {
5846 Region_IsVisible2(self, rect, g)
5847 }
5848 #[inline]
5849 pub unsafe fn IsVisible3(&self, rect: *const RectF, g: *const Graphics) -> BOOL {
5850 Region_IsVisible3(self, rect, g)
5851 }
5852 #[inline]
5853 pub unsafe fn Equals(&self, region: *const Region, g: *const Graphics) -> BOOL {
5854 Region_Equals(self, region, g)
5855 }
5856 #[inline]
5857 pub unsafe fn GetRegionScansCount(&self, matrix: *const Matrix) -> UINT {
5858 Region_GetRegionScansCount(self, matrix)
5859 }
5860 #[inline]
5861 pub unsafe fn GetRegionScans(
5862 &self,
5863 matrix: *const Matrix,
5864 rects: *mut RectF,
5865 count: *mut INT,
5866 ) -> Status {
5867 Region_GetRegionScans(self, matrix, rects, count)
5868 }
5869 #[inline]
5870 pub unsafe fn GetRegionScans1(
5871 &self,
5872 matrix: *const Matrix,
5873 rects: *mut Rect,
5874 count: *mut INT,
5875 ) -> Status {
5876 Region_GetRegionScans1(self, matrix, rects, count)
5877 }
5878 #[inline]
5879 pub unsafe fn GetLastStatus(&self) -> Status {
5880 Region_GetLastStatus(self)
5881 }
5882 #[inline]
5883 pub unsafe fn SetNativeRegion(&mut self, nativeRegion: *mut GpRegion) {
5884 Region_SetNativeRegion(self, nativeRegion)
5885 }
5886 #[inline]
5887 pub unsafe fn new() -> Self {
5888 let mut __bindgen_tmp = MaybeUninit::uninit();
5889 Region_Region(__bindgen_tmp.as_mut_ptr());
5890 __bindgen_tmp.assume_init()
5891 }
5892 #[inline]
5893 pub unsafe fn new1(rect: *const RectF) -> Self {
5894 let mut __bindgen_tmp = MaybeUninit::uninit();
5895 Region_Region1(__bindgen_tmp.as_mut_ptr(), rect);
5896 __bindgen_tmp.assume_init()
5897 }
5898 #[inline]
5899 pub unsafe fn new2(rect: *const Rect) -> Self {
5900 let mut __bindgen_tmp = MaybeUninit::uninit();
5901 Region_Region2(__bindgen_tmp.as_mut_ptr(), rect);
5902 __bindgen_tmp.assume_init()
5903 }
5904 #[inline]
5905 pub unsafe fn new3(path: *const GraphicsPath) -> Self {
5906 let mut __bindgen_tmp = MaybeUninit::uninit();
5907 Region_Region3(__bindgen_tmp.as_mut_ptr(), path);
5908 __bindgen_tmp.assume_init()
5909 }
5910 #[inline]
5911 pub unsafe fn new4(regionData: *const BYTE, size: INT) -> Self {
5912 let mut __bindgen_tmp = MaybeUninit::uninit();
5913 Region_Region4(__bindgen_tmp.as_mut_ptr(), regionData, size);
5914 __bindgen_tmp.assume_init()
5915 }
5916 #[inline]
5917 pub unsafe fn new5(hRgn: HRGN) -> Self {
5918 let mut __bindgen_tmp = MaybeUninit::uninit();
5919 Region_Region5(__bindgen_tmp.as_mut_ptr(), hRgn);
5920 __bindgen_tmp.assume_init()
5921 }
5922 #[inline]
5923 pub unsafe fn new6(nativeRegion: *mut GpRegion) -> Self {
5924 let mut __bindgen_tmp = MaybeUninit::uninit();
5925 Region_Region6(__bindgen_tmp.as_mut_ptr(), nativeRegion);
5926 __bindgen_tmp.assume_init()
5927 }
5928 #[inline]
5929 pub unsafe fn destruct(&mut self) {
5930 Region_Region_destructor(self)
5931 }
5932}
5933#[repr(C)]
5934#[derive(Debug)]
5935pub struct FontFamily {
5936 pub nativeFamily: *mut GpFontFamily,
5937 pub lastResult: Status,
5938}
5939extern "C" {
5940 #[link_name = "\u{1}?GenericSansSerif@FontFamily@Gdiplus@@SAPEBV12@XZ"]
5941 pub fn FontFamily_GenericSansSerif() -> *const FontFamily;
5942}
5943extern "C" {
5944 #[link_name = "\u{1}?GenericSerif@FontFamily@Gdiplus@@SAPEBV12@XZ"]
5945 pub fn FontFamily_GenericSerif() -> *const FontFamily;
5946}
5947extern "C" {
5948 #[link_name = "\u{1}?GenericMonospace@FontFamily@Gdiplus@@SAPEBV12@XZ"]
5949 pub fn FontFamily_GenericMonospace() -> *const FontFamily;
5950}
5951extern "C" {
5952 #[link_name = "\u{1}?GetFamilyName@FontFamily@Gdiplus@@QEBA?AW4Status@2@PEA_WG@Z"]
5953 pub fn FontFamily_GetFamilyName(
5954 this: *const FontFamily,
5955 name: LPWSTR,
5956 language: LANGID,
5957 ) -> Status;
5958}
5959extern "C" {
5960 #[link_name = "\u{1}?Clone@FontFamily@Gdiplus@@QEBAPEAV12@XZ"]
5961 pub fn FontFamily_Clone(this: *const FontFamily) -> *mut FontFamily;
5962}
5963extern "C" {
5964 #[link_name = "\u{1}?IsStyleAvailable@FontFamily@Gdiplus@@QEBAHH@Z"]
5965 pub fn FontFamily_IsStyleAvailable(this: *const FontFamily, style: INT) -> BOOL;
5966}
5967extern "C" {
5968 #[link_name = "\u{1}?GetEmHeight@FontFamily@Gdiplus@@QEBAGH@Z"]
5969 pub fn FontFamily_GetEmHeight(this: *const FontFamily, style: INT) -> UINT16;
5970}
5971extern "C" {
5972 #[link_name = "\u{1}?GetCellAscent@FontFamily@Gdiplus@@QEBAGH@Z"]
5973 pub fn FontFamily_GetCellAscent(this: *const FontFamily, style: INT) -> UINT16;
5974}
5975extern "C" {
5976 #[link_name = "\u{1}?GetCellDescent@FontFamily@Gdiplus@@QEBAGH@Z"]
5977 pub fn FontFamily_GetCellDescent(this: *const FontFamily, style: INT) -> UINT16;
5978}
5979extern "C" {
5980 #[link_name = "\u{1}?GetLineSpacing@FontFamily@Gdiplus@@QEBAGH@Z"]
5981 pub fn FontFamily_GetLineSpacing(this: *const FontFamily, style: INT) -> UINT16;
5982}
5983extern "C" {
5984 #[link_name = "\u{1}?GetLastStatus@FontFamily@Gdiplus@@QEBA?AW4Status@2@XZ"]
5985 pub fn FontFamily_GetLastStatus(this: *const FontFamily) -> Status;
5986}
5987extern "C" {
5988 #[link_name = "\u{1}?SetStatus@FontFamily@Gdiplus@@IEBA?AW4Status@2@W432@@Z"]
5989 pub fn FontFamily_SetStatus(this: *const FontFamily, status: Status) -> Status;
5990}
5991extern "C" {
5992 #[link_name = "\u{1}??0FontFamily@Gdiplus@@QEAA@XZ"]
5993 pub fn FontFamily_FontFamily(this: *mut FontFamily);
5994}
5995extern "C" {
5996 #[link_name = "\u{1}??0FontFamily@Gdiplus@@QEAA@PEB_WPEBVFontCollection@1@@Z"]
5997 pub fn FontFamily_FontFamily1(
5998 this: *mut FontFamily,
5999 name: *const WCHAR,
6000 fontCollection: *const FontCollection,
6001 );
6002}
6003extern "C" {
6004 #[link_name = "\u{1}??0FontFamily@Gdiplus@@IEAA@PEAVGpFontFamily@1@W4Status@1@@Z"]
6005 pub fn FontFamily_FontFamily2(
6006 this: *mut FontFamily,
6007 nativeFamily: *mut GpFontFamily,
6008 status: Status,
6009 );
6010}
6011extern "C" {
6012 #[link_name = "\u{1}??_DFontFamily@Gdiplus@@QEAAXXZ"]
6013 pub fn FontFamily_FontFamily_destructor(this: *mut FontFamily);
6014}
6015impl FontFamily {
6016 #[inline]
6017 pub unsafe fn GenericSansSerif() -> *const FontFamily {
6018 FontFamily_GenericSansSerif()
6019 }
6020 #[inline]
6021 pub unsafe fn GenericSerif() -> *const FontFamily {
6022 FontFamily_GenericSerif()
6023 }
6024 #[inline]
6025 pub unsafe fn GenericMonospace() -> *const FontFamily {
6026 FontFamily_GenericMonospace()
6027 }
6028 #[inline]
6029 pub unsafe fn GetFamilyName(&self, name: LPWSTR, language: LANGID) -> Status {
6030 FontFamily_GetFamilyName(self, name, language)
6031 }
6032 #[inline]
6033 pub unsafe fn Clone(&self) -> *mut FontFamily {
6034 FontFamily_Clone(self)
6035 }
6036 #[inline]
6037 pub unsafe fn IsStyleAvailable(&self, style: INT) -> BOOL {
6038 FontFamily_IsStyleAvailable(self, style)
6039 }
6040 #[inline]
6041 pub unsafe fn GetEmHeight(&self, style: INT) -> UINT16 {
6042 FontFamily_GetEmHeight(self, style)
6043 }
6044 #[inline]
6045 pub unsafe fn GetCellAscent(&self, style: INT) -> UINT16 {
6046 FontFamily_GetCellAscent(self, style)
6047 }
6048 #[inline]
6049 pub unsafe fn GetCellDescent(&self, style: INT) -> UINT16 {
6050 FontFamily_GetCellDescent(self, style)
6051 }
6052 #[inline]
6053 pub unsafe fn GetLineSpacing(&self, style: INT) -> UINT16 {
6054 FontFamily_GetLineSpacing(self, style)
6055 }
6056 #[inline]
6057 pub unsafe fn GetLastStatus(&self) -> Status {
6058 FontFamily_GetLastStatus(self)
6059 }
6060 #[inline]
6061 pub unsafe fn SetStatus(&self, status: Status) -> Status {
6062 FontFamily_SetStatus(self, status)
6063 }
6064 #[inline]
6065 pub unsafe fn new() -> Self {
6066 let mut __bindgen_tmp = MaybeUninit::uninit();
6067 FontFamily_FontFamily(__bindgen_tmp.as_mut_ptr());
6068 __bindgen_tmp.assume_init()
6069 }
6070 #[inline]
6071 pub unsafe fn new1(name: *const WCHAR, fontCollection: *const FontCollection) -> Self {
6072 let mut __bindgen_tmp = MaybeUninit::uninit();
6073 FontFamily_FontFamily1(__bindgen_tmp.as_mut_ptr(), name, fontCollection);
6074 __bindgen_tmp.assume_init()
6075 }
6076 #[inline]
6077 pub unsafe fn new2(nativeFamily: *mut GpFontFamily, status: Status) -> Self {
6078 let mut __bindgen_tmp = MaybeUninit::uninit();
6079 FontFamily_FontFamily2(__bindgen_tmp.as_mut_ptr(), nativeFamily, status);
6080 __bindgen_tmp.assume_init()
6081 }
6082 #[inline]
6083 pub unsafe fn destruct(&mut self) {
6084 FontFamily_FontFamily_destructor(self)
6085 }
6086}
6087#[repr(C)]
6088#[derive(Debug)]
6089pub struct Font {
6090 pub nativeFont: *mut GpFont,
6091 pub lastResult: Status,
6092}
6093extern "C" {
6094 #[link_name = "\u{1}?GetLogFontA@Font@Gdiplus@@QEBA?AW4Status@2@PEBVGraphics@2@PEAUtagLOGFONTA@@@Z"]
6095 pub fn Font_GetLogFontA(
6096 this: *const Font,
6097 g: *const Graphics,
6098 logfontA: *mut LOGFONTA,
6099 ) -> Status;
6100}
6101extern "C" {
6102 #[link_name = "\u{1}?GetLogFontW@Font@Gdiplus@@QEBA?AW4Status@2@PEBVGraphics@2@PEAUtagLOGFONTW@@@Z"]
6103 pub fn Font_GetLogFontW(
6104 this: *const Font,
6105 g: *const Graphics,
6106 logfontW: *mut LOGFONTW,
6107 ) -> Status;
6108}
6109extern "C" {
6110 #[link_name = "\u{1}?Clone@Font@Gdiplus@@QEBAPEAV12@XZ"]
6111 pub fn Font_Clone(this: *const Font) -> *mut Font;
6112}
6113extern "C" {
6114 #[link_name = "\u{1}?IsAvailable@Font@Gdiplus@@QEBAHXZ"]
6115 pub fn Font_IsAvailable(this: *const Font) -> BOOL;
6116}
6117extern "C" {
6118 #[link_name = "\u{1}?GetStyle@Font@Gdiplus@@QEBAHXZ"]
6119 pub fn Font_GetStyle(this: *const Font) -> INT;
6120}
6121extern "C" {
6122 #[link_name = "\u{1}?GetSize@Font@Gdiplus@@QEBAMXZ"]
6123 pub fn Font_GetSize(this: *const Font) -> REAL;
6124}
6125extern "C" {
6126 #[link_name = "\u{1}?GetUnit@Font@Gdiplus@@QEBA?AW4Unit@2@XZ"]
6127 pub fn Font_GetUnit(this: *const Font) -> Unit;
6128}
6129extern "C" {
6130 #[link_name = "\u{1}?GetLastStatus@Font@Gdiplus@@QEBA?AW4Status@2@XZ"]
6131 pub fn Font_GetLastStatus(this: *const Font) -> Status;
6132}
6133extern "C" {
6134 #[link_name = "\u{1}?GetHeight@Font@Gdiplus@@QEBAMPEBVGraphics@2@@Z"]
6135 pub fn Font_GetHeight(this: *const Font, graphics: *const Graphics) -> REAL;
6136}
6137extern "C" {
6138 #[link_name = "\u{1}?GetHeight@Font@Gdiplus@@QEBAMM@Z"]
6139 pub fn Font_GetHeight1(this: *const Font, dpi: REAL) -> REAL;
6140}
6141extern "C" {
6142 #[link_name = "\u{1}?GetFamily@Font@Gdiplus@@QEBA?AW4Status@2@PEAVFontFamily@2@@Z"]
6143 pub fn Font_GetFamily(this: *const Font, family: *mut FontFamily) -> Status;
6144}
6145extern "C" {
6146 #[link_name = "\u{1}?SetNativeFont@Font@Gdiplus@@IEAAXPEAVGpFont@2@@Z"]
6147 pub fn Font_SetNativeFont(this: *mut Font, Font: *mut GpFont);
6148}
6149extern "C" {
6150 #[link_name = "\u{1}?SetStatus@Font@Gdiplus@@IEBA?AW4Status@2@W432@@Z"]
6151 pub fn Font_SetStatus(this: *const Font, status: Status) -> Status;
6152}
6153extern "C" {
6154 #[link_name = "\u{1}??0Font@Gdiplus@@QEAA@PEAUHDC__@@@Z"]
6155 pub fn Font_Font(this: *mut Font, hdc: HDC);
6156}
6157extern "C" {
6158 #[link_name = "\u{1}??0Font@Gdiplus@@QEAA@PEAUHDC__@@PEBUtagLOGFONTA@@@Z"]
6159 pub fn Font_Font1(this: *mut Font, hdc: HDC, logfont: *const LOGFONTA);
6160}
6161extern "C" {
6162 #[link_name = "\u{1}??0Font@Gdiplus@@QEAA@PEAUHDC__@@PEBUtagLOGFONTW@@@Z"]
6163 pub fn Font_Font2(this: *mut Font, hdc: HDC, logfont: *const LOGFONTW);
6164}
6165extern "C" {
6166 #[link_name = "\u{1}??0Font@Gdiplus@@QEAA@PEAUHDC__@@QEAUHFONT__@@@Z"]
6167 pub fn Font_Font3(this: *mut Font, hdc: HDC, hfont: HFONT);
6168}
6169extern "C" {
6170 #[link_name = "\u{1}??0Font@Gdiplus@@QEAA@PEBVFontFamily@1@MHW4Unit@1@@Z"]
6171 pub fn Font_Font4(
6172 this: *mut Font,
6173 family: *const FontFamily,
6174 emSize: REAL,
6175 style: INT,
6176 unit: Unit,
6177 );
6178}
6179extern "C" {
6180 #[link_name = "\u{1}??0Font@Gdiplus@@QEAA@PEB_WMHW4Unit@1@PEBVFontCollection@1@@Z"]
6181 pub fn Font_Font5(
6182 this: *mut Font,
6183 familyName: *const WCHAR,
6184 emSize: REAL,
6185 style: INT,
6186 unit: Unit,
6187 fontCollection: *const FontCollection,
6188 );
6189}
6190extern "C" {
6191 #[link_name = "\u{1}??0Font@Gdiplus@@IEAA@PEAVGpFont@1@W4Status@1@@Z"]
6192 pub fn Font_Font6(this: *mut Font, font: *mut GpFont, status: Status);
6193}
6194extern "C" {
6195 #[link_name = "\u{1}??_DFont@Gdiplus@@QEAAXXZ"]
6196 pub fn Font_Font_destructor(this: *mut Font);
6197}
6198impl Font {
6199 #[inline]
6200 pub unsafe fn GetLogFontA(&self, g: *const Graphics, logfontA: *mut LOGFONTA) -> Status {
6201 Font_GetLogFontA(self, g, logfontA)
6202 }
6203 #[inline]
6204 pub unsafe fn GetLogFontW(&self, g: *const Graphics, logfontW: *mut LOGFONTW) -> Status {
6205 Font_GetLogFontW(self, g, logfontW)
6206 }
6207 #[inline]
6208 pub unsafe fn Clone(&self) -> *mut Font {
6209 Font_Clone(self)
6210 }
6211 #[inline]
6212 pub unsafe fn IsAvailable(&self) -> BOOL {
6213 Font_IsAvailable(self)
6214 }
6215 #[inline]
6216 pub unsafe fn GetStyle(&self) -> INT {
6217 Font_GetStyle(self)
6218 }
6219 #[inline]
6220 pub unsafe fn GetSize(&self) -> REAL {
6221 Font_GetSize(self)
6222 }
6223 #[inline]
6224 pub unsafe fn GetUnit(&self) -> Unit {
6225 Font_GetUnit(self)
6226 }
6227 #[inline]
6228 pub unsafe fn GetLastStatus(&self) -> Status {
6229 Font_GetLastStatus(self)
6230 }
6231 #[inline]
6232 pub unsafe fn GetHeight(&self, graphics: *const Graphics) -> REAL {
6233 Font_GetHeight(self, graphics)
6234 }
6235 #[inline]
6236 pub unsafe fn GetHeight1(&self, dpi: REAL) -> REAL {
6237 Font_GetHeight1(self, dpi)
6238 }
6239 #[inline]
6240 pub unsafe fn GetFamily(&self, family: *mut FontFamily) -> Status {
6241 Font_GetFamily(self, family)
6242 }
6243 #[inline]
6244 pub unsafe fn SetNativeFont(&mut self, Font: *mut GpFont) {
6245 Font_SetNativeFont(self, Font)
6246 }
6247 #[inline]
6248 pub unsafe fn SetStatus(&self, status: Status) -> Status {
6249 Font_SetStatus(self, status)
6250 }
6251 #[inline]
6252 pub unsafe fn new(hdc: HDC) -> Self {
6253 let mut __bindgen_tmp = MaybeUninit::uninit();
6254 Font_Font(__bindgen_tmp.as_mut_ptr(), hdc);
6255 __bindgen_tmp.assume_init()
6256 }
6257 #[inline]
6258 pub unsafe fn new1(hdc: HDC, logfont: *const LOGFONTA) -> Self {
6259 let mut __bindgen_tmp = MaybeUninit::uninit();
6260 Font_Font1(__bindgen_tmp.as_mut_ptr(), hdc, logfont);
6261 __bindgen_tmp.assume_init()
6262 }
6263 #[inline]
6264 pub unsafe fn new2(hdc: HDC, logfont: *const LOGFONTW) -> Self {
6265 let mut __bindgen_tmp = MaybeUninit::uninit();
6266 Font_Font2(__bindgen_tmp.as_mut_ptr(), hdc, logfont);
6267 __bindgen_tmp.assume_init()
6268 }
6269 #[inline]
6270 pub unsafe fn new3(hdc: HDC, hfont: HFONT) -> Self {
6271 let mut __bindgen_tmp = MaybeUninit::uninit();
6272 Font_Font3(__bindgen_tmp.as_mut_ptr(), hdc, hfont);
6273 __bindgen_tmp.assume_init()
6274 }
6275 #[inline]
6276 pub unsafe fn new4(family: *const FontFamily, emSize: REAL, style: INT, unit: Unit) -> Self {
6277 let mut __bindgen_tmp = MaybeUninit::uninit();
6278 Font_Font4(__bindgen_tmp.as_mut_ptr(), family, emSize, style, unit);
6279 __bindgen_tmp.assume_init()
6280 }
6281 #[inline]
6282 pub unsafe fn new5(
6283 familyName: *const WCHAR,
6284 emSize: REAL,
6285 style: INT,
6286 unit: Unit,
6287 fontCollection: *const FontCollection,
6288 ) -> Self {
6289 let mut __bindgen_tmp = MaybeUninit::uninit();
6290 Font_Font5(
6291 __bindgen_tmp.as_mut_ptr(),
6292 familyName,
6293 emSize,
6294 style,
6295 unit,
6296 fontCollection,
6297 );
6298 __bindgen_tmp.assume_init()
6299 }
6300 #[inline]
6301 pub unsafe fn new6(font: *mut GpFont, status: Status) -> Self {
6302 let mut __bindgen_tmp = MaybeUninit::uninit();
6303 Font_Font6(__bindgen_tmp.as_mut_ptr(), font, status);
6304 __bindgen_tmp.assume_init()
6305 }
6306 #[inline]
6307 pub unsafe fn destruct(&mut self) {
6308 Font_Font_destructor(self)
6309 }
6310}
6311#[repr(C)]
6312pub struct FontCollection__bindgen_vtable(c_void);
6313#[repr(C)]
6314#[derive(Debug)]
6315pub struct FontCollection {
6316 pub vtable_: *const FontCollection__bindgen_vtable,
6317 pub nativeFontCollection: *mut GpFontCollection,
6318 pub lastResult: Status,
6319}
6320extern "C" {
6321 #[link_name = "\u{1}?GetFamilyCount@FontCollection@Gdiplus@@QEBAHXZ"]
6322 pub fn FontCollection_GetFamilyCount(this: *const FontCollection) -> INT;
6323}
6324extern "C" {
6325 #[link_name = "\u{1}?GetFamilies@FontCollection@Gdiplus@@QEBA?AW4Status@2@HPEAVFontFamily@2@PEAH@Z"]
6326 pub fn FontCollection_GetFamilies(
6327 this: *const FontCollection,
6328 numSought: INT,
6329 gpfamilies: *mut FontFamily,
6330 numFound: *mut INT,
6331 ) -> Status;
6332}
6333extern "C" {
6334 #[link_name = "\u{1}?GetLastStatus@FontCollection@Gdiplus@@QEBA?AW4Status@2@XZ"]
6335 pub fn FontCollection_GetLastStatus(this: *const FontCollection) -> Status;
6336}
6337extern "C" {
6338 #[link_name = "\u{1}?SetStatus@FontCollection@Gdiplus@@IEBA?AW4Status@2@W432@@Z"]
6339 pub fn FontCollection_SetStatus(this: *const FontCollection, status: Status) -> Status;
6340}
6341extern "C" {
6342 #[link_name = "\u{1}??0FontCollection@Gdiplus@@QEAA@XZ"]
6343 pub fn FontCollection_FontCollection(this: *mut FontCollection);
6344}
6345impl FontCollection {
6346 #[inline]
6347 pub unsafe fn GetFamilyCount(&self) -> INT {
6348 FontCollection_GetFamilyCount(self)
6349 }
6350 #[inline]
6351 pub unsafe fn GetFamilies(
6352 &self,
6353 numSought: INT,
6354 gpfamilies: *mut FontFamily,
6355 numFound: *mut INT,
6356 ) -> Status {
6357 FontCollection_GetFamilies(self, numSought, gpfamilies, numFound)
6358 }
6359 #[inline]
6360 pub unsafe fn GetLastStatus(&self) -> Status {
6361 FontCollection_GetLastStatus(self)
6362 }
6363 #[inline]
6364 pub unsafe fn SetStatus(&self, status: Status) -> Status {
6365 FontCollection_SetStatus(self, status)
6366 }
6367 #[inline]
6368 pub unsafe fn new() -> Self {
6369 let mut __bindgen_tmp = MaybeUninit::uninit();
6370 FontCollection_FontCollection(__bindgen_tmp.as_mut_ptr());
6371 __bindgen_tmp.assume_init()
6372 }
6373}
6374extern "C" {
6375 #[link_name = "\u{1}??_DFontCollection@Gdiplus@@QEAAXXZ"]
6376 pub fn FontCollection_FontCollection_destructor(this: *mut FontCollection);
6377}
6378#[repr(C)]
6379#[derive(Debug)]
6380pub struct InstalledFontCollection {
6381 pub _base: FontCollection,
6382}
6383extern "C" {
6384 #[link_name = "\u{1}?SetStatus@InstalledFontCollection@Gdiplus@@IEBA?AW4Status@2@W432@@Z"]
6385 pub fn InstalledFontCollection_SetStatus(
6386 this: *const InstalledFontCollection,
6387 status: Status,
6388 ) -> Status;
6389}
6390extern "C" {
6391 #[link_name = "\u{1}??0InstalledFontCollection@Gdiplus@@QEAA@XZ"]
6392 pub fn InstalledFontCollection_InstalledFontCollection(this: *mut InstalledFontCollection);
6393}
6394impl InstalledFontCollection {
6395 #[inline]
6396 pub unsafe fn SetStatus(&self, status: Status) -> Status {
6397 InstalledFontCollection_SetStatus(self, status)
6398 }
6399 #[inline]
6400 pub unsafe fn new() -> Self {
6401 let mut __bindgen_tmp = MaybeUninit::uninit();
6402 InstalledFontCollection_InstalledFontCollection(__bindgen_tmp.as_mut_ptr());
6403 __bindgen_tmp.assume_init()
6404 }
6405}
6406extern "C" {
6407 #[link_name = "\u{1}??_DInstalledFontCollection@Gdiplus@@QEAAXXZ"]
6408 pub fn InstalledFontCollection_InstalledFontCollection_destructor(
6409 this: *mut InstalledFontCollection,
6410 );
6411}
6412#[repr(C)]
6413#[derive(Debug)]
6414pub struct PrivateFontCollection {
6415 pub _base: FontCollection,
6416}
6417extern "C" {
6418 #[link_name = "\u{1}?AddFontFile@PrivateFontCollection@Gdiplus@@QEAA?AW4Status@2@PEB_W@Z"]
6419 pub fn PrivateFontCollection_AddFontFile(
6420 this: *mut PrivateFontCollection,
6421 filename: *const WCHAR,
6422 ) -> Status;
6423}
6424extern "C" {
6425 #[link_name = "\u{1}?AddMemoryFont@PrivateFontCollection@Gdiplus@@QEAA?AW4Status@2@PEBXH@Z"]
6426 pub fn PrivateFontCollection_AddMemoryFont(
6427 this: *mut PrivateFontCollection,
6428 memory: *const c_void,
6429 length: INT,
6430 ) -> Status;
6431}
6432extern "C" {
6433 #[link_name = "\u{1}??0PrivateFontCollection@Gdiplus@@QEAA@XZ"]
6434 pub fn PrivateFontCollection_PrivateFontCollection(this: *mut PrivateFontCollection);
6435}
6436impl PrivateFontCollection {
6437 #[inline]
6438 pub unsafe fn AddFontFile(&mut self, filename: *const WCHAR) -> Status {
6439 PrivateFontCollection_AddFontFile(self, filename)
6440 }
6441 #[inline]
6442 pub unsafe fn AddMemoryFont(&mut self, memory: *const c_void, length: INT) -> Status {
6443 PrivateFontCollection_AddMemoryFont(self, memory, length)
6444 }
6445 #[inline]
6446 pub unsafe fn new() -> Self {
6447 let mut __bindgen_tmp = MaybeUninit::uninit();
6448 PrivateFontCollection_PrivateFontCollection(__bindgen_tmp.as_mut_ptr());
6449 __bindgen_tmp.assume_init()
6450 }
6451}
6452extern "C" {
6453 #[link_name = "\u{1}??_DPrivateFontCollection@Gdiplus@@QEAAXXZ"]
6454 pub fn PrivateFontCollection_PrivateFontCollection_destructor(this: *mut PrivateFontCollection);
6455}
6456#[repr(C)]
6457pub struct Image__bindgen_vtable(c_void);
6458#[repr(C)]
6459#[derive(Debug)]
6460pub struct Image {
6461 pub vtable_: *const Image__bindgen_vtable,
6462 pub nativeImage: *mut GpImage,
6463 pub lastResult: Status,
6464 pub loadStatus: Status,
6465}
6466extern "C" {
6467 #[link_name = "\u{1}?FromFile@Image@Gdiplus@@SAPEAV12@PEB_WH@Z"]
6468 pub fn Image_FromFile(filename: *const WCHAR, useEmbeddedColorManagement: BOOL) -> *mut Image;
6469}
6470extern "C" {
6471 #[link_name = "\u{1}?FromStream@Image@Gdiplus@@SAPEAV12@PEAUIStream@@H@Z"]
6472 pub fn Image_FromStream(stream: *mut IStream, useEmbeddedColorManagement: BOOL) -> *mut Image;
6473}
6474extern "C" {
6475 #[link_name = "\u{1}?Save@Image@Gdiplus@@QEAA?AW4Status@2@PEB_WPEBU_GUID@@PEBVEncoderParameters@2@@Z"]
6476 pub fn Image_Save(
6477 this: *mut Image,
6478 filename: *const WCHAR,
6479 clsidEncoder: *const CLSID,
6480 encoderParams: *const EncoderParameters,
6481 ) -> Status;
6482}
6483extern "C" {
6484 #[link_name = "\u{1}?Save@Image@Gdiplus@@QEAA?AW4Status@2@PEAUIStream@@PEBU_GUID@@PEBVEncoderParameters@2@@Z"]
6485 pub fn Image_Save1(
6486 this: *mut Image,
6487 stream: *mut IStream,
6488 clsidEncoder: *const CLSID,
6489 encoderParams: *const EncoderParameters,
6490 ) -> Status;
6491}
6492extern "C" {
6493 #[link_name = "\u{1}?SaveAdd@Image@Gdiplus@@QEAA?AW4Status@2@PEBVEncoderParameters@2@@Z"]
6494 pub fn Image_SaveAdd(this: *mut Image, encoderParams: *const EncoderParameters) -> Status;
6495}
6496extern "C" {
6497 #[link_name = "\u{1}?SaveAdd@Image@Gdiplus@@QEAA?AW4Status@2@PEAV12@PEBVEncoderParameters@2@@Z"]
6498 pub fn Image_SaveAdd1(
6499 this: *mut Image,
6500 newImage: *mut Image,
6501 encoderParams: *const EncoderParameters,
6502 ) -> Status;
6503}
6504extern "C" {
6505 #[link_name = "\u{1}?GetType@Image@Gdiplus@@QEBA?AW4ImageType@2@XZ"]
6506 pub fn Image_GetType(this: *const Image) -> ImageType;
6507}
6508extern "C" {
6509 #[link_name = "\u{1}?GetPhysicalDimension@Image@Gdiplus@@QEAA?AW4Status@2@PEAVSizeF@2@@Z"]
6510 pub fn Image_GetPhysicalDimension(this: *mut Image, size: *mut SizeF) -> Status;
6511}
6512extern "C" {
6513 #[link_name = "\u{1}?GetBounds@Image@Gdiplus@@QEAA?AW4Status@2@PEAVRectF@2@PEAW4Unit@2@@Z"]
6514 pub fn Image_GetBounds(this: *mut Image, srcRect: *mut RectF, srcUnit: *mut Unit) -> Status;
6515}
6516extern "C" {
6517 #[link_name = "\u{1}?GetWidth@Image@Gdiplus@@QEAAIXZ"]
6518 pub fn Image_GetWidth(this: *mut Image) -> UINT;
6519}
6520extern "C" {
6521 #[link_name = "\u{1}?GetHeight@Image@Gdiplus@@QEAAIXZ"]
6522 pub fn Image_GetHeight(this: *mut Image) -> UINT;
6523}
6524extern "C" {
6525 #[link_name = "\u{1}?GetHorizontalResolution@Image@Gdiplus@@QEAAMXZ"]
6526 pub fn Image_GetHorizontalResolution(this: *mut Image) -> REAL;
6527}
6528extern "C" {
6529 #[link_name = "\u{1}?GetVerticalResolution@Image@Gdiplus@@QEAAMXZ"]
6530 pub fn Image_GetVerticalResolution(this: *mut Image) -> REAL;
6531}
6532extern "C" {
6533 #[link_name = "\u{1}?GetFlags@Image@Gdiplus@@QEAAIXZ"]
6534 pub fn Image_GetFlags(this: *mut Image) -> UINT;
6535}
6536extern "C" {
6537 #[link_name = "\u{1}?GetRawFormat@Image@Gdiplus@@QEAA?AW4Status@2@PEAU_GUID@@@Z"]
6538 pub fn Image_GetRawFormat(this: *mut Image, format: *mut GUID) -> Status;
6539}
6540extern "C" {
6541 #[link_name = "\u{1}?GetPixelFormat@Image@Gdiplus@@QEAAHXZ"]
6542 pub fn Image_GetPixelFormat(this: *mut Image) -> PixelFormat;
6543}
6544extern "C" {
6545 #[link_name = "\u{1}?GetPaletteSize@Image@Gdiplus@@QEAAHXZ"]
6546 pub fn Image_GetPaletteSize(this: *mut Image) -> INT;
6547}
6548extern "C" {
6549 #[link_name = "\u{1}?GetPalette@Image@Gdiplus@@QEAA?AW4Status@2@PEAUColorPalette@2@H@Z"]
6550 pub fn Image_GetPalette(this: *mut Image, palette: *mut ColorPalette, size: INT) -> Status;
6551}
6552extern "C" {
6553 #[link_name = "\u{1}?SetPalette@Image@Gdiplus@@QEAA?AW4Status@2@PEBUColorPalette@2@@Z"]
6554 pub fn Image_SetPalette(this: *mut Image, palette: *const ColorPalette) -> Status;
6555}
6556extern "C" {
6557 #[link_name = "\u{1}?GetThumbnailImage@Image@Gdiplus@@QEAAPEAV12@IIP6AHPEAX@Z0@Z"]
6558 pub fn Image_GetThumbnailImage(
6559 this: *mut Image,
6560 thumbWidth: UINT,
6561 thumbHeight: UINT,
6562 callback: GetThumbnailImageAbort,
6563 callbackData: *mut c_void,
6564 ) -> *mut Image;
6565}
6566extern "C" {
6567 #[link_name = "\u{1}?GetFrameDimensionsCount@Image@Gdiplus@@QEAAIXZ"]
6568 pub fn Image_GetFrameDimensionsCount(this: *mut Image) -> UINT;
6569}
6570extern "C" {
6571 #[link_name = "\u{1}?GetFrameDimensionsList@Image@Gdiplus@@QEAA?AW4Status@2@PEAU_GUID@@I@Z"]
6572 pub fn Image_GetFrameDimensionsList(
6573 this: *mut Image,
6574 dimensionIDs: *mut GUID,
6575 count: UINT,
6576 ) -> Status;
6577}
6578extern "C" {
6579 #[link_name = "\u{1}?GetFrameCount@Image@Gdiplus@@QEAAIPEBU_GUID@@@Z"]
6580 pub fn Image_GetFrameCount(this: *mut Image, dimensionID: *const GUID) -> UINT;
6581}
6582extern "C" {
6583 #[link_name = "\u{1}?SelectActiveFrame@Image@Gdiplus@@QEAA?AW4Status@2@PEBU_GUID@@I@Z"]
6584 pub fn Image_SelectActiveFrame(
6585 this: *mut Image,
6586 dimensionID: *const GUID,
6587 frameIndex: UINT,
6588 ) -> Status;
6589}
6590extern "C" {
6591 #[link_name = "\u{1}?RotateFlip@Image@Gdiplus@@QEAA?AW4Status@2@W4RotateFlipType@2@@Z"]
6592 pub fn Image_RotateFlip(this: *mut Image, rotateFlipType: RotateFlipType) -> Status;
6593}
6594extern "C" {
6595 #[link_name = "\u{1}?GetPropertyCount@Image@Gdiplus@@QEAAIXZ"]
6596 pub fn Image_GetPropertyCount(this: *mut Image) -> UINT;
6597}
6598extern "C" {
6599 #[link_name = "\u{1}?GetPropertyIdList@Image@Gdiplus@@QEAA?AW4Status@2@IPEAK@Z"]
6600 pub fn Image_GetPropertyIdList(
6601 this: *mut Image,
6602 numOfProperty: UINT,
6603 list: *mut PROPID,
6604 ) -> Status;
6605}
6606extern "C" {
6607 #[link_name = "\u{1}?GetPropertyItemSize@Image@Gdiplus@@QEAAIK@Z"]
6608 pub fn Image_GetPropertyItemSize(this: *mut Image, propId: PROPID) -> UINT;
6609}
6610extern "C" {
6611 #[link_name = "\u{1}?GetPropertyItem@Image@Gdiplus@@QEAA?AW4Status@2@KIPEAVPropertyItem@2@@Z"]
6612 pub fn Image_GetPropertyItem(
6613 this: *mut Image,
6614 propId: PROPID,
6615 propSize: UINT,
6616 buffer: *mut PropertyItem,
6617 ) -> Status;
6618}
6619extern "C" {
6620 #[link_name = "\u{1}?GetPropertySize@Image@Gdiplus@@QEAA?AW4Status@2@PEAI0@Z"]
6621 pub fn Image_GetPropertySize(
6622 this: *mut Image,
6623 totalBufferSize: *mut UINT,
6624 numProperties: *mut UINT,
6625 ) -> Status;
6626}
6627extern "C" {
6628 #[link_name = "\u{1}?GetAllPropertyItems@Image@Gdiplus@@QEAA?AW4Status@2@IIPEAVPropertyItem@2@@Z"]
6629 pub fn Image_GetAllPropertyItems(
6630 this: *mut Image,
6631 totalBufferSize: UINT,
6632 numProperties: UINT,
6633 allItems: *mut PropertyItem,
6634 ) -> Status;
6635}
6636extern "C" {
6637 #[link_name = "\u{1}?RemovePropertyItem@Image@Gdiplus@@QEAA?AW4Status@2@K@Z"]
6638 pub fn Image_RemovePropertyItem(this: *mut Image, propId: PROPID) -> Status;
6639}
6640extern "C" {
6641 #[link_name = "\u{1}?SetPropertyItem@Image@Gdiplus@@QEAA?AW4Status@2@PEBVPropertyItem@2@@Z"]
6642 pub fn Image_SetPropertyItem(this: *mut Image, item: *const PropertyItem) -> Status;
6643}
6644extern "C" {
6645 #[link_name = "\u{1}?GetEncoderParameterListSize@Image@Gdiplus@@QEAAIPEBU_GUID@@@Z"]
6646 pub fn Image_GetEncoderParameterListSize(this: *mut Image, clsidEncoder: *const CLSID) -> UINT;
6647}
6648extern "C" {
6649 #[link_name = "\u{1}?GetEncoderParameterList@Image@Gdiplus@@QEAA?AW4Status@2@PEBU_GUID@@IPEAVEncoderParameters@2@@Z"]
6650 pub fn Image_GetEncoderParameterList(
6651 this: *mut Image,
6652 clsidEncoder: *const CLSID,
6653 size: UINT,
6654 buffer: *mut EncoderParameters,
6655 ) -> Status;
6656}
6657extern "C" {
6658 #[link_name = "\u{1}?GetLastStatus@Image@Gdiplus@@QEBA?AW4Status@2@XZ"]
6659 pub fn Image_GetLastStatus(this: *const Image) -> Status;
6660}
6661extern "C" {
6662 #[link_name = "\u{1}?SetNativeImage@Image@Gdiplus@@IEAAXPEAVGpImage@2@@Z"]
6663 pub fn Image_SetNativeImage(this: *mut Image, nativeImage: *mut GpImage);
6664}
6665extern "C" {
6666 #[link_name = "\u{1}??0Image@Gdiplus@@QEAA@PEB_WH@Z"]
6667 pub fn Image_Image(this: *mut Image, filename: *const WCHAR, useEmbeddedColorManagement: BOOL);
6668}
6669extern "C" {
6670 #[link_name = "\u{1}??0Image@Gdiplus@@QEAA@PEAUIStream@@H@Z"]
6671 pub fn Image_Image1(this: *mut Image, stream: *mut IStream, useEmbeddedColorManagement: BOOL);
6672}
6673extern "C" {
6674 #[link_name = "\u{1}??0Image@Gdiplus@@IEAA@PEAVGpImage@1@W4Status@1@@Z"]
6675 pub fn Image_Image2(this: *mut Image, nativeImage: *mut GpImage, status: Status);
6676}
6677impl Image {
6678 #[inline]
6679 pub unsafe fn FromFile(filename: *const WCHAR, useEmbeddedColorManagement: BOOL) -> *mut Image {
6680 Image_FromFile(filename, useEmbeddedColorManagement)
6681 }
6682 #[inline]
6683 pub unsafe fn FromStream(stream: *mut IStream, useEmbeddedColorManagement: BOOL) -> *mut Image {
6684 Image_FromStream(stream, useEmbeddedColorManagement)
6685 }
6686 #[inline]
6687 pub unsafe fn Save(
6688 &mut self,
6689 filename: *const WCHAR,
6690 clsidEncoder: *const CLSID,
6691 encoderParams: *const EncoderParameters,
6692 ) -> Status {
6693 Image_Save(self, filename, clsidEncoder, encoderParams)
6694 }
6695 #[inline]
6696 pub unsafe fn Save1(
6697 &mut self,
6698 stream: *mut IStream,
6699 clsidEncoder: *const CLSID,
6700 encoderParams: *const EncoderParameters,
6701 ) -> Status {
6702 Image_Save1(self, stream, clsidEncoder, encoderParams)
6703 }
6704 #[inline]
6705 pub unsafe fn SaveAdd(&mut self, encoderParams: *const EncoderParameters) -> Status {
6706 Image_SaveAdd(self, encoderParams)
6707 }
6708 #[inline]
6709 pub unsafe fn SaveAdd1(
6710 &mut self,
6711 newImage: *mut Image,
6712 encoderParams: *const EncoderParameters,
6713 ) -> Status {
6714 Image_SaveAdd1(self, newImage, encoderParams)
6715 }
6716 #[inline]
6717 pub unsafe fn GetType(&self) -> ImageType {
6718 Image_GetType(self)
6719 }
6720 #[inline]
6721 pub unsafe fn GetPhysicalDimension(&mut self, size: *mut SizeF) -> Status {
6722 Image_GetPhysicalDimension(self, size)
6723 }
6724 #[inline]
6725 pub unsafe fn GetBounds(&mut self, srcRect: *mut RectF, srcUnit: *mut Unit) -> Status {
6726 Image_GetBounds(self, srcRect, srcUnit)
6727 }
6728 #[inline]
6729 pub unsafe fn GetWidth(&mut self) -> UINT {
6730 Image_GetWidth(self)
6731 }
6732 #[inline]
6733 pub unsafe fn GetHeight(&mut self) -> UINT {
6734 Image_GetHeight(self)
6735 }
6736 #[inline]
6737 pub unsafe fn GetHorizontalResolution(&mut self) -> REAL {
6738 Image_GetHorizontalResolution(self)
6739 }
6740 #[inline]
6741 pub unsafe fn GetVerticalResolution(&mut self) -> REAL {
6742 Image_GetVerticalResolution(self)
6743 }
6744 #[inline]
6745 pub unsafe fn GetFlags(&mut self) -> UINT {
6746 Image_GetFlags(self)
6747 }
6748 #[inline]
6749 pub unsafe fn GetRawFormat(&mut self, format: *mut GUID) -> Status {
6750 Image_GetRawFormat(self, format)
6751 }
6752 #[inline]
6753 pub unsafe fn GetPixelFormat(&mut self) -> PixelFormat {
6754 Image_GetPixelFormat(self)
6755 }
6756 #[inline]
6757 pub unsafe fn GetPaletteSize(&mut self) -> INT {
6758 Image_GetPaletteSize(self)
6759 }
6760 #[inline]
6761 pub unsafe fn GetPalette(&mut self, palette: *mut ColorPalette, size: INT) -> Status {
6762 Image_GetPalette(self, palette, size)
6763 }
6764 #[inline]
6765 pub unsafe fn SetPalette(&mut self, palette: *const ColorPalette) -> Status {
6766 Image_SetPalette(self, palette)
6767 }
6768 #[inline]
6769 pub unsafe fn GetThumbnailImage(
6770 &mut self,
6771 thumbWidth: UINT,
6772 thumbHeight: UINT,
6773 callback: GetThumbnailImageAbort,
6774 callbackData: *mut c_void,
6775 ) -> *mut Image {
6776 Image_GetThumbnailImage(self, thumbWidth, thumbHeight, callback, callbackData)
6777 }
6778 #[inline]
6779 pub unsafe fn GetFrameDimensionsCount(&mut self) -> UINT {
6780 Image_GetFrameDimensionsCount(self)
6781 }
6782 #[inline]
6783 pub unsafe fn GetFrameDimensionsList(
6784 &mut self,
6785 dimensionIDs: *mut GUID,
6786 count: UINT,
6787 ) -> Status {
6788 Image_GetFrameDimensionsList(self, dimensionIDs, count)
6789 }
6790 #[inline]
6791 pub unsafe fn GetFrameCount(&mut self, dimensionID: *const GUID) -> UINT {
6792 Image_GetFrameCount(self, dimensionID)
6793 }
6794 #[inline]
6795 pub unsafe fn SelectActiveFrame(
6796 &mut self,
6797 dimensionID: *const GUID,
6798 frameIndex: UINT,
6799 ) -> Status {
6800 Image_SelectActiveFrame(self, dimensionID, frameIndex)
6801 }
6802 #[inline]
6803 pub unsafe fn RotateFlip(&mut self, rotateFlipType: RotateFlipType) -> Status {
6804 Image_RotateFlip(self, rotateFlipType)
6805 }
6806 #[inline]
6807 pub unsafe fn GetPropertyCount(&mut self) -> UINT {
6808 Image_GetPropertyCount(self)
6809 }
6810 #[inline]
6811 pub unsafe fn GetPropertyIdList(&mut self, numOfProperty: UINT, list: *mut PROPID) -> Status {
6812 Image_GetPropertyIdList(self, numOfProperty, list)
6813 }
6814 #[inline]
6815 pub unsafe fn GetPropertyItemSize(&mut self, propId: PROPID) -> UINT {
6816 Image_GetPropertyItemSize(self, propId)
6817 }
6818 #[inline]
6819 pub unsafe fn GetPropertyItem(
6820 &mut self,
6821 propId: PROPID,
6822 propSize: UINT,
6823 buffer: *mut PropertyItem,
6824 ) -> Status {
6825 Image_GetPropertyItem(self, propId, propSize, buffer)
6826 }
6827 #[inline]
6828 pub unsafe fn GetPropertySize(
6829 &mut self,
6830 totalBufferSize: *mut UINT,
6831 numProperties: *mut UINT,
6832 ) -> Status {
6833 Image_GetPropertySize(self, totalBufferSize, numProperties)
6834 }
6835 #[inline]
6836 pub unsafe fn GetAllPropertyItems(
6837 &mut self,
6838 totalBufferSize: UINT,
6839 numProperties: UINT,
6840 allItems: *mut PropertyItem,
6841 ) -> Status {
6842 Image_GetAllPropertyItems(self, totalBufferSize, numProperties, allItems)
6843 }
6844 #[inline]
6845 pub unsafe fn RemovePropertyItem(&mut self, propId: PROPID) -> Status {
6846 Image_RemovePropertyItem(self, propId)
6847 }
6848 #[inline]
6849 pub unsafe fn SetPropertyItem(&mut self, item: *const PropertyItem) -> Status {
6850 Image_SetPropertyItem(self, item)
6851 }
6852 #[inline]
6853 pub unsafe fn GetEncoderParameterListSize(&mut self, clsidEncoder: *const CLSID) -> UINT {
6854 Image_GetEncoderParameterListSize(self, clsidEncoder)
6855 }
6856 #[inline]
6857 pub unsafe fn GetEncoderParameterList(
6858 &mut self,
6859 clsidEncoder: *const CLSID,
6860 size: UINT,
6861 buffer: *mut EncoderParameters,
6862 ) -> Status {
6863 Image_GetEncoderParameterList(self, clsidEncoder, size, buffer)
6864 }
6865 #[inline]
6866 pub unsafe fn GetLastStatus(&self) -> Status {
6867 Image_GetLastStatus(self)
6868 }
6869 #[inline]
6870 pub unsafe fn SetNativeImage(&mut self, nativeImage: *mut GpImage) {
6871 Image_SetNativeImage(self, nativeImage)
6872 }
6873 #[inline]
6874 pub unsafe fn new(filename: *const WCHAR, useEmbeddedColorManagement: BOOL) -> Self {
6875 let mut __bindgen_tmp = MaybeUninit::uninit();
6876 Image_Image(
6877 __bindgen_tmp.as_mut_ptr(),
6878 filename,
6879 useEmbeddedColorManagement,
6880 );
6881 __bindgen_tmp.assume_init()
6882 }
6883 #[inline]
6884 pub unsafe fn new1(stream: *mut IStream, useEmbeddedColorManagement: BOOL) -> Self {
6885 let mut __bindgen_tmp = MaybeUninit::uninit();
6886 Image_Image1(
6887 __bindgen_tmp.as_mut_ptr(),
6888 stream,
6889 useEmbeddedColorManagement,
6890 );
6891 __bindgen_tmp.assume_init()
6892 }
6893 #[inline]
6894 pub unsafe fn new2(nativeImage: *mut GpImage, status: Status) -> Self {
6895 let mut __bindgen_tmp = MaybeUninit::uninit();
6896 Image_Image2(__bindgen_tmp.as_mut_ptr(), nativeImage, status);
6897 __bindgen_tmp.assume_init()
6898 }
6899}
6900extern "C" {
6901 #[link_name = "\u{1}??_DImage@Gdiplus@@QEAAXXZ"]
6902 pub fn Image_Image_destructor(this: *mut Image);
6903}
6904extern "C" {
6905 #[link_name = "\u{1}?Clone@Image@Gdiplus@@UEAAPEAV12@XZ"]
6906 pub fn Image_Clone(this: *mut c_void) -> *mut Image;
6907}
6908#[repr(C)]
6909#[derive(Debug)]
6910pub struct Bitmap {
6911 pub _base: Image,
6912}
6913extern "C" {
6914 #[link_name = "\u{1}?FromFile@Bitmap@Gdiplus@@SAPEAV12@PEB_WH@Z"]
6915 pub fn Bitmap_FromFile(filename: *const WCHAR, useEmbeddedColorManagement: BOOL)
6916 -> *mut Bitmap;
6917}
6918extern "C" {
6919 #[link_name = "\u{1}?FromStream@Bitmap@Gdiplus@@SAPEAV12@PEAUIStream@@H@Z"]
6920 pub fn Bitmap_FromStream(stream: *mut IStream, useEmbeddedColorManagement: BOOL)
6921 -> *mut Bitmap;
6922}
6923extern "C" {
6924 #[link_name = "\u{1}?Clone@Bitmap@Gdiplus@@QEAAPEAV12@AEBVRect@2@H@Z"]
6925 pub fn Bitmap_Clone(this: *mut Bitmap, rect: *const Rect, format: PixelFormat) -> *mut Bitmap;
6926}
6927extern "C" {
6928 #[link_name = "\u{1}?Clone@Bitmap@Gdiplus@@QEAAPEAV12@HHHHH@Z"]
6929 pub fn Bitmap_Clone1(
6930 this: *mut Bitmap,
6931 x: INT,
6932 y: INT,
6933 width: INT,
6934 height: INT,
6935 format: PixelFormat,
6936 ) -> *mut Bitmap;
6937}
6938extern "C" {
6939 #[link_name = "\u{1}?Clone@Bitmap@Gdiplus@@QEAAPEAV12@AEBVRectF@2@H@Z"]
6940 pub fn Bitmap_Clone2(this: *mut Bitmap, rect: *const RectF, format: PixelFormat)
6941 -> *mut Bitmap;
6942}
6943extern "C" {
6944 #[link_name = "\u{1}?Clone@Bitmap@Gdiplus@@QEAAPEAV12@MMMMH@Z"]
6945 pub fn Bitmap_Clone3(
6946 this: *mut Bitmap,
6947 x: REAL,
6948 y: REAL,
6949 width: REAL,
6950 height: REAL,
6951 format: PixelFormat,
6952 ) -> *mut Bitmap;
6953}
6954extern "C" {
6955 #[link_name = "\u{1}?LockBits@Bitmap@Gdiplus@@QEAA?AW4Status@2@PEBVRect@2@IHPEAVBitmapData@2@@Z"]
6956 pub fn Bitmap_LockBits(
6957 this: *mut Bitmap,
6958 rect: *const Rect,
6959 flags: UINT,
6960 format: PixelFormat,
6961 lockedBitmapData: *mut BitmapData,
6962 ) -> Status;
6963}
6964extern "C" {
6965 #[link_name = "\u{1}?UnlockBits@Bitmap@Gdiplus@@QEAA?AW4Status@2@PEAVBitmapData@2@@Z"]
6966 pub fn Bitmap_UnlockBits(this: *mut Bitmap, lockedBitmapData: *mut BitmapData) -> Status;
6967}
6968extern "C" {
6969 #[link_name = "\u{1}?GetPixel@Bitmap@Gdiplus@@QEAA?AW4Status@2@HHPEAVColor@2@@Z"]
6970 pub fn Bitmap_GetPixel(this: *mut Bitmap, x: INT, y: INT, color: *mut Color) -> Status;
6971}
6972extern "C" {
6973 #[link_name = "\u{1}?SetPixel@Bitmap@Gdiplus@@QEAA?AW4Status@2@HHAEBVColor@2@@Z"]
6974 pub fn Bitmap_SetPixel(this: *mut Bitmap, x: INT, y: INT, color: *const Color) -> Status;
6975}
6976extern "C" {
6977 #[link_name = "\u{1}?SetResolution@Bitmap@Gdiplus@@QEAA?AW4Status@2@MM@Z"]
6978 pub fn Bitmap_SetResolution(this: *mut Bitmap, xdpi: REAL, ydpi: REAL) -> Status;
6979}
6980extern "C" {
6981 #[link_name = "\u{1}?FromDirectDrawSurface7@Bitmap@Gdiplus@@SAPEAV12@PEAUIDirectDrawSurface7@@@Z"]
6982 pub fn Bitmap_FromDirectDrawSurface7(surface: *mut IDirectDrawSurface7) -> *mut Bitmap;
6983}
6984extern "C" {
6985 #[link_name = "\u{1}?FromBITMAPINFO@Bitmap@Gdiplus@@SAPEAV12@PEBUtagBITMAPINFO@@PEAX@Z"]
6986 pub fn Bitmap_FromBITMAPINFO(
6987 gdiBitmapInfo: *const BITMAPINFO,
6988 gdiBitmapData: *mut c_void,
6989 ) -> *mut Bitmap;
6990}
6991extern "C" {
6992 #[link_name = "\u{1}?FromHBITMAP@Bitmap@Gdiplus@@SAPEAV12@PEAUHBITMAP__@@PEAUHPALETTE__@@@Z"]
6993 pub fn Bitmap_FromHBITMAP(hbm: HBITMAP, hpal: HPALETTE) -> *mut Bitmap;
6994}
6995extern "C" {
6996 #[link_name = "\u{1}?FromHICON@Bitmap@Gdiplus@@SAPEAV12@PEAUHICON__@@@Z"]
6997 pub fn Bitmap_FromHICON(hicon: HICON) -> *mut Bitmap;
6998}
6999extern "C" {
7000 #[link_name = "\u{1}?FromResource@Bitmap@Gdiplus@@SAPEAV12@PEAUHINSTANCE__@@PEB_W@Z"]
7001 pub fn Bitmap_FromResource(hInstance: HINSTANCE, bitmapName: *const WCHAR) -> *mut Bitmap;
7002}
7003extern "C" {
7004 #[link_name = "\u{1}?GetHBITMAP@Bitmap@Gdiplus@@QEAA?AW4Status@2@AEBVColor@2@PEAPEAUHBITMAP__@@@Z"]
7005 pub fn Bitmap_GetHBITMAP(
7006 this: *mut Bitmap,
7007 colorBackground: *const Color,
7008 hbmReturn: *mut HBITMAP,
7009 ) -> Status;
7010}
7011extern "C" {
7012 #[link_name = "\u{1}?GetHICON@Bitmap@Gdiplus@@QEAA?AW4Status@2@PEAPEAUHICON__@@@Z"]
7013 pub fn Bitmap_GetHICON(this: *mut Bitmap, hicon: *mut HICON) -> Status;
7014}
7015extern "C" {
7016 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@PEB_WH@Z"]
7017 pub fn Bitmap_Bitmap(
7018 this: *mut Bitmap,
7019 filename: *const WCHAR,
7020 useEmbeddedColorManagement: BOOL,
7021 );
7022}
7023extern "C" {
7024 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@PEAUIStream@@H@Z"]
7025 pub fn Bitmap_Bitmap1(
7026 this: *mut Bitmap,
7027 stream: *mut IStream,
7028 useEmbeddedColorManagement: BOOL,
7029 );
7030}
7031extern "C" {
7032 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@HHHHPEAE@Z"]
7033 pub fn Bitmap_Bitmap2(
7034 this: *mut Bitmap,
7035 width: INT,
7036 height: INT,
7037 stride: INT,
7038 format: PixelFormat,
7039 scan0: *mut BYTE,
7040 );
7041}
7042extern "C" {
7043 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@HHH@Z"]
7044 pub fn Bitmap_Bitmap3(this: *mut Bitmap, width: INT, height: INT, format: PixelFormat);
7045}
7046extern "C" {
7047 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@HHPEAVGraphics@1@@Z"]
7048 pub fn Bitmap_Bitmap4(this: *mut Bitmap, width: INT, height: INT, target: *mut Graphics);
7049}
7050extern "C" {
7051 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@PEAUIDirectDrawSurface7@@@Z"]
7052 pub fn Bitmap_Bitmap5(this: *mut Bitmap, surface: *mut IDirectDrawSurface7);
7053}
7054extern "C" {
7055 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@PEBUtagBITMAPINFO@@PEAX@Z"]
7056 pub fn Bitmap_Bitmap6(
7057 this: *mut Bitmap,
7058 gdiBitmapInfo: *const BITMAPINFO,
7059 gdiBitmapData: *mut c_void,
7060 );
7061}
7062extern "C" {
7063 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@PEAUHBITMAP__@@PEAUHPALETTE__@@@Z"]
7064 pub fn Bitmap_Bitmap7(this: *mut Bitmap, hbm: HBITMAP, hpal: HPALETTE);
7065}
7066extern "C" {
7067 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@PEAUHICON__@@@Z"]
7068 pub fn Bitmap_Bitmap8(this: *mut Bitmap, hicon: HICON);
7069}
7070extern "C" {
7071 #[link_name = "\u{1}??0Bitmap@Gdiplus@@QEAA@PEAUHINSTANCE__@@PEB_W@Z"]
7072 pub fn Bitmap_Bitmap9(this: *mut Bitmap, hInstance: HINSTANCE, bitmapName: *const WCHAR);
7073}
7074extern "C" {
7075 #[link_name = "\u{1}??0Bitmap@Gdiplus@@IEAA@PEAVGpBitmap@1@@Z"]
7076 pub fn Bitmap_Bitmap10(this: *mut Bitmap, nativeBitmap: *mut GpBitmap);
7077}
7078impl Bitmap {
7079 #[inline]
7080 pub unsafe fn FromFile(
7081 filename: *const WCHAR,
7082 useEmbeddedColorManagement: BOOL,
7083 ) -> *mut Bitmap {
7084 Bitmap_FromFile(filename, useEmbeddedColorManagement)
7085 }
7086 #[inline]
7087 pub unsafe fn FromStream(
7088 stream: *mut IStream,
7089 useEmbeddedColorManagement: BOOL,
7090 ) -> *mut Bitmap {
7091 Bitmap_FromStream(stream, useEmbeddedColorManagement)
7092 }
7093 #[inline]
7094 pub unsafe fn Clone(&mut self, rect: *const Rect, format: PixelFormat) -> *mut Bitmap {
7095 Bitmap_Clone(self, rect, format)
7096 }
7097 #[inline]
7098 pub unsafe fn Clone1(
7099 &mut self,
7100 x: INT,
7101 y: INT,
7102 width: INT,
7103 height: INT,
7104 format: PixelFormat,
7105 ) -> *mut Bitmap {
7106 Bitmap_Clone1(self, x, y, width, height, format)
7107 }
7108 #[inline]
7109 pub unsafe fn Clone2(&mut self, rect: *const RectF, format: PixelFormat) -> *mut Bitmap {
7110 Bitmap_Clone2(self, rect, format)
7111 }
7112 #[inline]
7113 pub unsafe fn Clone3(
7114 &mut self,
7115 x: REAL,
7116 y: REAL,
7117 width: REAL,
7118 height: REAL,
7119 format: PixelFormat,
7120 ) -> *mut Bitmap {
7121 Bitmap_Clone3(self, x, y, width, height, format)
7122 }
7123 #[inline]
7124 pub unsafe fn LockBits(
7125 &mut self,
7126 rect: *const Rect,
7127 flags: UINT,
7128 format: PixelFormat,
7129 lockedBitmapData: *mut BitmapData,
7130 ) -> Status {
7131 Bitmap_LockBits(self, rect, flags, format, lockedBitmapData)
7132 }
7133 #[inline]
7134 pub unsafe fn UnlockBits(&mut self, lockedBitmapData: *mut BitmapData) -> Status {
7135 Bitmap_UnlockBits(self, lockedBitmapData)
7136 }
7137 #[inline]
7138 pub unsafe fn GetPixel(&mut self, x: INT, y: INT, color: *mut Color) -> Status {
7139 Bitmap_GetPixel(self, x, y, color)
7140 }
7141 #[inline]
7142 pub unsafe fn SetPixel(&mut self, x: INT, y: INT, color: *const Color) -> Status {
7143 Bitmap_SetPixel(self, x, y, color)
7144 }
7145 #[inline]
7146 pub unsafe fn SetResolution(&mut self, xdpi: REAL, ydpi: REAL) -> Status {
7147 Bitmap_SetResolution(self, xdpi, ydpi)
7148 }
7149 #[inline]
7150 pub unsafe fn FromDirectDrawSurface7(surface: *mut IDirectDrawSurface7) -> *mut Bitmap {
7151 Bitmap_FromDirectDrawSurface7(surface)
7152 }
7153 #[inline]
7154 pub unsafe fn FromBITMAPINFO(
7155 gdiBitmapInfo: *const BITMAPINFO,
7156 gdiBitmapData: *mut c_void,
7157 ) -> *mut Bitmap {
7158 Bitmap_FromBITMAPINFO(gdiBitmapInfo, gdiBitmapData)
7159 }
7160 #[inline]
7161 pub unsafe fn FromHBITMAP(hbm: HBITMAP, hpal: HPALETTE) -> *mut Bitmap {
7162 Bitmap_FromHBITMAP(hbm, hpal)
7163 }
7164 #[inline]
7165 pub unsafe fn FromHICON(hicon: HICON) -> *mut Bitmap {
7166 Bitmap_FromHICON(hicon)
7167 }
7168 #[inline]
7169 pub unsafe fn FromResource(hInstance: HINSTANCE, bitmapName: *const WCHAR) -> *mut Bitmap {
7170 Bitmap_FromResource(hInstance, bitmapName)
7171 }
7172 #[inline]
7173 pub unsafe fn GetHBITMAP(
7174 &mut self,
7175 colorBackground: *const Color,
7176 hbmReturn: *mut HBITMAP,
7177 ) -> Status {
7178 Bitmap_GetHBITMAP(self, colorBackground, hbmReturn)
7179 }
7180 #[inline]
7181 pub unsafe fn GetHICON(&mut self, hicon: *mut HICON) -> Status {
7182 Bitmap_GetHICON(self, hicon)
7183 }
7184 #[inline]
7185 pub unsafe fn new(filename: *const WCHAR, useEmbeddedColorManagement: BOOL) -> Self {
7186 let mut __bindgen_tmp = MaybeUninit::uninit();
7187 Bitmap_Bitmap(
7188 __bindgen_tmp.as_mut_ptr(),
7189 filename,
7190 useEmbeddedColorManagement,
7191 );
7192 __bindgen_tmp.assume_init()
7193 }
7194 #[inline]
7195 pub unsafe fn new1(stream: *mut IStream, useEmbeddedColorManagement: BOOL) -> Self {
7196 let mut __bindgen_tmp = MaybeUninit::uninit();
7197 Bitmap_Bitmap1(
7198 __bindgen_tmp.as_mut_ptr(),
7199 stream,
7200 useEmbeddedColorManagement,
7201 );
7202 __bindgen_tmp.assume_init()
7203 }
7204 #[inline]
7205 pub unsafe fn new2(
7206 width: INT,
7207 height: INT,
7208 stride: INT,
7209 format: PixelFormat,
7210 scan0: *mut BYTE,
7211 ) -> Self {
7212 let mut __bindgen_tmp = MaybeUninit::uninit();
7213 Bitmap_Bitmap2(
7214 __bindgen_tmp.as_mut_ptr(),
7215 width,
7216 height,
7217 stride,
7218 format,
7219 scan0,
7220 );
7221 __bindgen_tmp.assume_init()
7222 }
7223 #[inline]
7224 pub unsafe fn new3(width: INT, height: INT, format: PixelFormat) -> Self {
7225 let mut __bindgen_tmp = MaybeUninit::uninit();
7226 Bitmap_Bitmap3(__bindgen_tmp.as_mut_ptr(), width, height, format);
7227 __bindgen_tmp.assume_init()
7228 }
7229 #[inline]
7230 pub unsafe fn new4(width: INT, height: INT, target: *mut Graphics) -> Self {
7231 let mut __bindgen_tmp = MaybeUninit::uninit();
7232 Bitmap_Bitmap4(__bindgen_tmp.as_mut_ptr(), width, height, target);
7233 __bindgen_tmp.assume_init()
7234 }
7235 #[inline]
7236 pub unsafe fn new5(surface: *mut IDirectDrawSurface7) -> Self {
7237 let mut __bindgen_tmp = MaybeUninit::uninit();
7238 Bitmap_Bitmap5(__bindgen_tmp.as_mut_ptr(), surface);
7239 __bindgen_tmp.assume_init()
7240 }
7241 #[inline]
7242 pub unsafe fn new6(gdiBitmapInfo: *const BITMAPINFO, gdiBitmapData: *mut c_void) -> Self {
7243 let mut __bindgen_tmp = MaybeUninit::uninit();
7244 Bitmap_Bitmap6(__bindgen_tmp.as_mut_ptr(), gdiBitmapInfo, gdiBitmapData);
7245 __bindgen_tmp.assume_init()
7246 }
7247 #[inline]
7248 pub unsafe fn new7(hbm: HBITMAP, hpal: HPALETTE) -> Self {
7249 let mut __bindgen_tmp = MaybeUninit::uninit();
7250 Bitmap_Bitmap7(__bindgen_tmp.as_mut_ptr(), hbm, hpal);
7251 __bindgen_tmp.assume_init()
7252 }
7253 #[inline]
7254 pub unsafe fn new8(hicon: HICON) -> Self {
7255 let mut __bindgen_tmp = MaybeUninit::uninit();
7256 Bitmap_Bitmap8(__bindgen_tmp.as_mut_ptr(), hicon);
7257 __bindgen_tmp.assume_init()
7258 }
7259 #[inline]
7260 pub unsafe fn new9(hInstance: HINSTANCE, bitmapName: *const WCHAR) -> Self {
7261 let mut __bindgen_tmp = MaybeUninit::uninit();
7262 Bitmap_Bitmap9(__bindgen_tmp.as_mut_ptr(), hInstance, bitmapName);
7263 __bindgen_tmp.assume_init()
7264 }
7265 #[inline]
7266 pub unsafe fn new10(nativeBitmap: *mut GpBitmap) -> Self {
7267 let mut __bindgen_tmp = MaybeUninit::uninit();
7268 Bitmap_Bitmap10(__bindgen_tmp.as_mut_ptr(), nativeBitmap);
7269 __bindgen_tmp.assume_init()
7270 }
7271}
7272#[repr(C)]
7273pub struct CustomLineCap__bindgen_vtable(c_void);
7274#[repr(C)]
7275#[derive(Debug)]
7276pub struct CustomLineCap {
7277 pub vtable_: *const CustomLineCap__bindgen_vtable,
7278 pub nativeCap: *mut GpCustomLineCap,
7279 pub lastResult: Status,
7280}
7281extern "C" {
7282 #[link_name = "\u{1}?Clone@CustomLineCap@Gdiplus@@QEBAPEAV12@XZ"]
7283 pub fn CustomLineCap_Clone(this: *const CustomLineCap) -> *mut CustomLineCap;
7284}
7285extern "C" {
7286 #[link_name = "\u{1}?SetStrokeCaps@CustomLineCap@Gdiplus@@QEAA?AW4Status@2@W4LineCap@2@0@Z"]
7287 pub fn CustomLineCap_SetStrokeCaps(
7288 this: *mut CustomLineCap,
7289 startCap: LineCap,
7290 endCap: LineCap,
7291 ) -> Status;
7292}
7293extern "C" {
7294 #[link_name = "\u{1}?GetStrokeCaps@CustomLineCap@Gdiplus@@QEBA?AW4Status@2@PEAW4LineCap@2@0@Z"]
7295 pub fn CustomLineCap_GetStrokeCaps(
7296 this: *const CustomLineCap,
7297 startCap: *mut LineCap,
7298 endCap: *mut LineCap,
7299 ) -> Status;
7300}
7301extern "C" {
7302 #[link_name = "\u{1}?SetStrokeJoin@CustomLineCap@Gdiplus@@QEAA?AW4Status@2@W4LineJoin@2@@Z"]
7303 pub fn CustomLineCap_SetStrokeJoin(this: *mut CustomLineCap, lineJoin: LineJoin) -> Status;
7304}
7305extern "C" {
7306 #[link_name = "\u{1}?GetStrokeJoin@CustomLineCap@Gdiplus@@QEBA?AW4LineJoin@2@XZ"]
7307 pub fn CustomLineCap_GetStrokeJoin(this: *const CustomLineCap) -> LineJoin;
7308}
7309extern "C" {
7310 #[link_name = "\u{1}?SetBaseCap@CustomLineCap@Gdiplus@@QEAA?AW4Status@2@W4LineCap@2@@Z"]
7311 pub fn CustomLineCap_SetBaseCap(this: *mut CustomLineCap, baseCap: LineCap) -> Status;
7312}
7313extern "C" {
7314 #[link_name = "\u{1}?GetBaseCap@CustomLineCap@Gdiplus@@QEBA?AW4LineCap@2@XZ"]
7315 pub fn CustomLineCap_GetBaseCap(this: *const CustomLineCap) -> LineCap;
7316}
7317extern "C" {
7318 #[link_name = "\u{1}?SetBaseInset@CustomLineCap@Gdiplus@@QEAA?AW4Status@2@M@Z"]
7319 pub fn CustomLineCap_SetBaseInset(this: *mut CustomLineCap, inset: REAL) -> Status;
7320}
7321extern "C" {
7322 #[link_name = "\u{1}?GetBaseInset@CustomLineCap@Gdiplus@@QEBAMXZ"]
7323 pub fn CustomLineCap_GetBaseInset(this: *const CustomLineCap) -> REAL;
7324}
7325extern "C" {
7326 #[link_name = "\u{1}?SetWidthScale@CustomLineCap@Gdiplus@@QEAA?AW4Status@2@M@Z"]
7327 pub fn CustomLineCap_SetWidthScale(this: *mut CustomLineCap, widthScale: REAL) -> Status;
7328}
7329extern "C" {
7330 #[link_name = "\u{1}?GetWidthScale@CustomLineCap@Gdiplus@@QEBAMXZ"]
7331 pub fn CustomLineCap_GetWidthScale(this: *const CustomLineCap) -> REAL;
7332}
7333extern "C" {
7334 #[link_name = "\u{1}?GetLastStatus@CustomLineCap@Gdiplus@@QEBA?AW4Status@2@XZ"]
7335 pub fn CustomLineCap_GetLastStatus(this: *const CustomLineCap) -> Status;
7336}
7337extern "C" {
7338 #[link_name = "\u{1}??0CustomLineCap@Gdiplus@@QEAA@PEBVGraphicsPath@1@0W4LineCap@1@M@Z"]
7339 pub fn CustomLineCap_CustomLineCap(
7340 this: *mut CustomLineCap,
7341 fillPath: *const GraphicsPath,
7342 strokePath: *const GraphicsPath,
7343 baseCap: LineCap,
7344 baseInset: REAL,
7345 );
7346}
7347extern "C" {
7348 #[link_name = "\u{1}??0CustomLineCap@Gdiplus@@IEAA@XZ"]
7349 pub fn CustomLineCap_CustomLineCap1(this: *mut CustomLineCap);
7350}
7351impl CustomLineCap {
7352 #[inline]
7353 pub unsafe fn Clone(&self) -> *mut CustomLineCap {
7354 CustomLineCap_Clone(self)
7355 }
7356 #[inline]
7357 pub unsafe fn SetStrokeCaps(&mut self, startCap: LineCap, endCap: LineCap) -> Status {
7358 CustomLineCap_SetStrokeCaps(self, startCap, endCap)
7359 }
7360 #[inline]
7361 pub unsafe fn GetStrokeCaps(&self, startCap: *mut LineCap, endCap: *mut LineCap) -> Status {
7362 CustomLineCap_GetStrokeCaps(self, startCap, endCap)
7363 }
7364 #[inline]
7365 pub unsafe fn SetStrokeJoin(&mut self, lineJoin: LineJoin) -> Status {
7366 CustomLineCap_SetStrokeJoin(self, lineJoin)
7367 }
7368 #[inline]
7369 pub unsafe fn GetStrokeJoin(&self) -> LineJoin {
7370 CustomLineCap_GetStrokeJoin(self)
7371 }
7372 #[inline]
7373 pub unsafe fn SetBaseCap(&mut self, baseCap: LineCap) -> Status {
7374 CustomLineCap_SetBaseCap(self, baseCap)
7375 }
7376 #[inline]
7377 pub unsafe fn GetBaseCap(&self) -> LineCap {
7378 CustomLineCap_GetBaseCap(self)
7379 }
7380 #[inline]
7381 pub unsafe fn SetBaseInset(&mut self, inset: REAL) -> Status {
7382 CustomLineCap_SetBaseInset(self, inset)
7383 }
7384 #[inline]
7385 pub unsafe fn GetBaseInset(&self) -> REAL {
7386 CustomLineCap_GetBaseInset(self)
7387 }
7388 #[inline]
7389 pub unsafe fn SetWidthScale(&mut self, widthScale: REAL) -> Status {
7390 CustomLineCap_SetWidthScale(self, widthScale)
7391 }
7392 #[inline]
7393 pub unsafe fn GetWidthScale(&self) -> REAL {
7394 CustomLineCap_GetWidthScale(self)
7395 }
7396 #[inline]
7397 pub unsafe fn GetLastStatus(&self) -> Status {
7398 CustomLineCap_GetLastStatus(self)
7399 }
7400 #[inline]
7401 pub unsafe fn new(
7402 fillPath: *const GraphicsPath,
7403 strokePath: *const GraphicsPath,
7404 baseCap: LineCap,
7405 baseInset: REAL,
7406 ) -> Self {
7407 let mut __bindgen_tmp = MaybeUninit::uninit();
7408 CustomLineCap_CustomLineCap(
7409 __bindgen_tmp.as_mut_ptr(),
7410 fillPath,
7411 strokePath,
7412 baseCap,
7413 baseInset,
7414 );
7415 __bindgen_tmp.assume_init()
7416 }
7417 #[inline]
7418 pub unsafe fn new1() -> Self {
7419 let mut __bindgen_tmp = MaybeUninit::uninit();
7420 CustomLineCap_CustomLineCap1(__bindgen_tmp.as_mut_ptr());
7421 __bindgen_tmp.assume_init()
7422 }
7423}
7424extern "C" {
7425 #[link_name = "\u{1}??_DCustomLineCap@Gdiplus@@QEAAXXZ"]
7426 pub fn CustomLineCap_CustomLineCap_destructor(this: *mut CustomLineCap);
7427}
7428#[repr(C)]
7429pub struct CachedBitmap__bindgen_vtable(c_void);
7430#[repr(C)]
7431#[derive(Debug)]
7432pub struct CachedBitmap {
7433 pub vtable_: *const CachedBitmap__bindgen_vtable,
7434 pub nativeCachedBitmap: *mut GpCachedBitmap,
7435 pub lastResult: Status,
7436}
7437extern "C" {
7438 #[link_name = "\u{1}?GetLastStatus@CachedBitmap@Gdiplus@@QEBA?AW4Status@2@XZ"]
7439 pub fn CachedBitmap_GetLastStatus(this: *const CachedBitmap) -> Status;
7440}
7441extern "C" {
7442 #[link_name = "\u{1}??0CachedBitmap@Gdiplus@@QEAA@PEAVBitmap@1@PEAVGraphics@1@@Z"]
7443 pub fn CachedBitmap_CachedBitmap(
7444 this: *mut CachedBitmap,
7445 bitmap: *mut Bitmap,
7446 graphics: *mut Graphics,
7447 );
7448}
7449impl CachedBitmap {
7450 #[inline]
7451 pub unsafe fn GetLastStatus(&self) -> Status {
7452 CachedBitmap_GetLastStatus(self)
7453 }
7454 #[inline]
7455 pub unsafe fn new(bitmap: *mut Bitmap, graphics: *mut Graphics) -> Self {
7456 let mut __bindgen_tmp = MaybeUninit::uninit();
7457 CachedBitmap_CachedBitmap(__bindgen_tmp.as_mut_ptr(), bitmap, graphics);
7458 __bindgen_tmp.assume_init()
7459 }
7460}
7461extern "C" {
7462 #[link_name = "\u{1}??_DCachedBitmap@Gdiplus@@QEAAXXZ"]
7463 pub fn CachedBitmap_CachedBitmap_destructor(this: *mut CachedBitmap);
7464}
7465#[repr(C)]
7466#[derive(Debug)]
7467pub struct Metafile {
7468 pub _base: Image,
7469}
7470extern "C" {
7471 #[link_name = "\u{1}?GetMetafileHeader@Metafile@Gdiplus@@SA?AW4Status@2@PEAUHMETAFILE__@@PEBUWmfPlaceableFileHeader@2@PEAVMetafileHeader@2@@Z"]
7472 pub fn Metafile_GetMetafileHeader(
7473 hWmf: HMETAFILE,
7474 wmfPlaceableFileHeader: *const WmfPlaceableFileHeader,
7475 header: *mut MetafileHeader,
7476 ) -> Status;
7477}
7478extern "C" {
7479 #[link_name = "\u{1}?GetMetafileHeader@Metafile@Gdiplus@@SA?AW4Status@2@PEAUHENHMETAFILE__@@PEAVMetafileHeader@2@@Z"]
7480 pub fn Metafile_GetMetafileHeader1(hEmf: HENHMETAFILE, header: *mut MetafileHeader) -> Status;
7481}
7482extern "C" {
7483 #[link_name = "\u{1}?GetMetafileHeader@Metafile@Gdiplus@@SA?AW4Status@2@PEB_WPEAVMetafileHeader@2@@Z"]
7484 pub fn Metafile_GetMetafileHeader2(
7485 filename: *const WCHAR,
7486 header: *mut MetafileHeader,
7487 ) -> Status;
7488}
7489extern "C" {
7490 #[link_name = "\u{1}?GetMetafileHeader@Metafile@Gdiplus@@SA?AW4Status@2@PEAUIStream@@PEAVMetafileHeader@2@@Z"]
7491 pub fn Metafile_GetMetafileHeader3(stream: *mut IStream, header: *mut MetafileHeader)
7492 -> Status;
7493}
7494extern "C" {
7495 #[link_name = "\u{1}?GetMetafileHeader@Metafile@Gdiplus@@QEBA?AW4Status@2@PEAVMetafileHeader@2@@Z"]
7496 pub fn Metafile_GetMetafileHeader4(
7497 this: *const Metafile,
7498 header: *mut MetafileHeader,
7499 ) -> Status;
7500}
7501extern "C" {
7502 #[link_name = "\u{1}?GetHENHMETAFILE@Metafile@Gdiplus@@QEAAPEAUHENHMETAFILE__@@XZ"]
7503 pub fn Metafile_GetHENHMETAFILE(this: *mut Metafile) -> HENHMETAFILE;
7504}
7505extern "C" {
7506 #[link_name = "\u{1}?PlayRecord@Metafile@Gdiplus@@QEBA?AW4Status@2@W4EmfPlusRecordType@2@IIPEBE@Z"]
7507 pub fn Metafile_PlayRecord(
7508 this: *const Metafile,
7509 recordType: EmfPlusRecordType,
7510 flags: UINT,
7511 dataSize: UINT,
7512 data: *const BYTE,
7513 ) -> Status;
7514}
7515extern "C" {
7516 #[link_name = "\u{1}?SetDownLevelRasterizationLimit@Metafile@Gdiplus@@QEAA?AW4Status@2@I@Z"]
7517 pub fn Metafile_SetDownLevelRasterizationLimit(
7518 this: *mut Metafile,
7519 metafileRasterizationLimitDpi: UINT,
7520 ) -> Status;
7521}
7522extern "C" {
7523 #[link_name = "\u{1}?GetDownLevelRasterizationLimit@Metafile@Gdiplus@@QEBAIXZ"]
7524 pub fn Metafile_GetDownLevelRasterizationLimit(this: *const Metafile) -> UINT;
7525}
7526extern "C" {
7527 #[link_name = "\u{1}?EmfToWmfBits@Metafile@Gdiplus@@SAIPEAUHENHMETAFILE__@@IPEAEHH@Z"]
7528 pub fn Metafile_EmfToWmfBits(
7529 hemf: HENHMETAFILE,
7530 cbData16: UINT,
7531 pData16: LPBYTE,
7532 iMapMode: INT,
7533 eFlags: INT,
7534 ) -> UINT;
7535}
7536extern "C" {
7537 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEAUHMETAFILE__@@PEBUWmfPlaceableFileHeader@1@H@Z"]
7538 pub fn Metafile_Metafile(
7539 this: *mut Metafile,
7540 hWmf: HMETAFILE,
7541 wmfPlaceableFileHeader: *const WmfPlaceableFileHeader,
7542 deleteWmf: BOOL,
7543 );
7544}
7545extern "C" {
7546 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEAUHENHMETAFILE__@@H@Z"]
7547 pub fn Metafile_Metafile1(this: *mut Metafile, hEmf: HENHMETAFILE, deleteEmf: BOOL);
7548}
7549extern "C" {
7550 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEB_W@Z"]
7551 pub fn Metafile_Metafile2(this: *mut Metafile, filename: *const WCHAR);
7552}
7553extern "C" {
7554 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEB_WPEBUWmfPlaceableFileHeader@1@@Z"]
7555 pub fn Metafile_Metafile3(
7556 this: *mut Metafile,
7557 filename: *const WCHAR,
7558 wmfPlaceableFileHeader: *const WmfPlaceableFileHeader,
7559 );
7560}
7561extern "C" {
7562 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEAUIStream@@@Z"]
7563 pub fn Metafile_Metafile4(this: *mut Metafile, stream: *mut IStream);
7564}
7565extern "C" {
7566 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEAUHDC__@@W4EmfType@1@PEB_W@Z"]
7567 pub fn Metafile_Metafile5(
7568 this: *mut Metafile,
7569 referenceHdc: HDC,
7570 type_: EmfType,
7571 description: *const WCHAR,
7572 );
7573}
7574extern "C" {
7575 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEAUHDC__@@AEBVRectF@1@W4MetafileFrameUnit@1@W4EmfType@1@PEB_W@Z"]
7576 pub fn Metafile_Metafile6(
7577 this: *mut Metafile,
7578 referenceHdc: HDC,
7579 frameRect: *const RectF,
7580 frameUnit: MetafileFrameUnit,
7581 type_: EmfType,
7582 description: *const WCHAR,
7583 );
7584}
7585extern "C" {
7586 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEAUHDC__@@AEBVRect@1@W4MetafileFrameUnit@1@W4EmfType@1@PEB_W@Z"]
7587 pub fn Metafile_Metafile7(
7588 this: *mut Metafile,
7589 referenceHdc: HDC,
7590 frameRect: *const Rect,
7591 frameUnit: MetafileFrameUnit,
7592 type_: EmfType,
7593 description: *const WCHAR,
7594 );
7595}
7596extern "C" {
7597 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEB_WPEAUHDC__@@W4EmfType@1@0@Z"]
7598 pub fn Metafile_Metafile8(
7599 this: *mut Metafile,
7600 fileName: *const WCHAR,
7601 referenceHdc: HDC,
7602 type_: EmfType,
7603 description: *const WCHAR,
7604 );
7605}
7606extern "C" {
7607 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEB_WPEAUHDC__@@AEBVRectF@1@W4MetafileFrameUnit@1@W4EmfType@1@0@Z"]
7608 pub fn Metafile_Metafile9(
7609 this: *mut Metafile,
7610 fileName: *const WCHAR,
7611 referenceHdc: HDC,
7612 frameRect: *const RectF,
7613 frameUnit: MetafileFrameUnit,
7614 type_: EmfType,
7615 description: *const WCHAR,
7616 );
7617}
7618extern "C" {
7619 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEB_WPEAUHDC__@@AEBVRect@1@W4MetafileFrameUnit@1@W4EmfType@1@0@Z"]
7620 pub fn Metafile_Metafile10(
7621 this: *mut Metafile,
7622 fileName: *const WCHAR,
7623 referenceHdc: HDC,
7624 frameRect: *const Rect,
7625 frameUnit: MetafileFrameUnit,
7626 type_: EmfType,
7627 description: *const WCHAR,
7628 );
7629}
7630extern "C" {
7631 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEAUIStream@@PEAUHDC__@@W4EmfType@1@PEB_W@Z"]
7632 pub fn Metafile_Metafile11(
7633 this: *mut Metafile,
7634 stream: *mut IStream,
7635 referenceHdc: HDC,
7636 type_: EmfType,
7637 description: *const WCHAR,
7638 );
7639}
7640extern "C" {
7641 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEAUIStream@@PEAUHDC__@@AEBVRectF@1@W4MetafileFrameUnit@1@W4EmfType@1@PEB_W@Z"]
7642 pub fn Metafile_Metafile12(
7643 this: *mut Metafile,
7644 stream: *mut IStream,
7645 referenceHdc: HDC,
7646 frameRect: *const RectF,
7647 frameUnit: MetafileFrameUnit,
7648 type_: EmfType,
7649 description: *const WCHAR,
7650 );
7651}
7652extern "C" {
7653 #[link_name = "\u{1}??0Metafile@Gdiplus@@QEAA@PEAUIStream@@PEAUHDC__@@AEBVRect@1@W4MetafileFrameUnit@1@W4EmfType@1@PEB_W@Z"]
7654 pub fn Metafile_Metafile13(
7655 this: *mut Metafile,
7656 stream: *mut IStream,
7657 referenceHdc: HDC,
7658 frameRect: *const Rect,
7659 frameUnit: MetafileFrameUnit,
7660 type_: EmfType,
7661 description: *const WCHAR,
7662 );
7663}
7664impl Metafile {
7665 #[inline]
7666 pub unsafe fn GetMetafileHeader(
7667 hWmf: HMETAFILE,
7668 wmfPlaceableFileHeader: *const WmfPlaceableFileHeader,
7669 header: *mut MetafileHeader,
7670 ) -> Status {
7671 Metafile_GetMetafileHeader(hWmf, wmfPlaceableFileHeader, header)
7672 }
7673 #[inline]
7674 pub unsafe fn GetMetafileHeader1(hEmf: HENHMETAFILE, header: *mut MetafileHeader) -> Status {
7675 Metafile_GetMetafileHeader1(hEmf, header)
7676 }
7677 #[inline]
7678 pub unsafe fn GetMetafileHeader2(
7679 filename: *const WCHAR,
7680 header: *mut MetafileHeader,
7681 ) -> Status {
7682 Metafile_GetMetafileHeader2(filename, header)
7683 }
7684 #[inline]
7685 pub unsafe fn GetMetafileHeader3(stream: *mut IStream, header: *mut MetafileHeader) -> Status {
7686 Metafile_GetMetafileHeader3(stream, header)
7687 }
7688 #[inline]
7689 pub unsafe fn GetMetafileHeader4(&self, header: *mut MetafileHeader) -> Status {
7690 Metafile_GetMetafileHeader4(self, header)
7691 }
7692 #[inline]
7693 pub unsafe fn GetHENHMETAFILE(&mut self) -> HENHMETAFILE {
7694 Metafile_GetHENHMETAFILE(self)
7695 }
7696 #[inline]
7697 pub unsafe fn PlayRecord(
7698 &self,
7699 recordType: EmfPlusRecordType,
7700 flags: UINT,
7701 dataSize: UINT,
7702 data: *const BYTE,
7703 ) -> Status {
7704 Metafile_PlayRecord(self, recordType, flags, dataSize, data)
7705 }
7706 #[inline]
7707 pub unsafe fn SetDownLevelRasterizationLimit(
7708 &mut self,
7709 metafileRasterizationLimitDpi: UINT,
7710 ) -> Status {
7711 Metafile_SetDownLevelRasterizationLimit(self, metafileRasterizationLimitDpi)
7712 }
7713 #[inline]
7714 pub unsafe fn GetDownLevelRasterizationLimit(&self) -> UINT {
7715 Metafile_GetDownLevelRasterizationLimit(self)
7716 }
7717 #[inline]
7718 pub unsafe fn EmfToWmfBits(
7719 hemf: HENHMETAFILE,
7720 cbData16: UINT,
7721 pData16: LPBYTE,
7722 iMapMode: INT,
7723 eFlags: INT,
7724 ) -> UINT {
7725 Metafile_EmfToWmfBits(hemf, cbData16, pData16, iMapMode, eFlags)
7726 }
7727 #[inline]
7728 pub unsafe fn new(
7729 hWmf: HMETAFILE,
7730 wmfPlaceableFileHeader: *const WmfPlaceableFileHeader,
7731 deleteWmf: BOOL,
7732 ) -> Self {
7733 let mut __bindgen_tmp = MaybeUninit::uninit();
7734 Metafile_Metafile(
7735 __bindgen_tmp.as_mut_ptr(),
7736 hWmf,
7737 wmfPlaceableFileHeader,
7738 deleteWmf,
7739 );
7740 __bindgen_tmp.assume_init()
7741 }
7742 #[inline]
7743 pub unsafe fn new1(hEmf: HENHMETAFILE, deleteEmf: BOOL) -> Self {
7744 let mut __bindgen_tmp = MaybeUninit::uninit();
7745 Metafile_Metafile1(__bindgen_tmp.as_mut_ptr(), hEmf, deleteEmf);
7746 __bindgen_tmp.assume_init()
7747 }
7748 #[inline]
7749 pub unsafe fn new2(filename: *const WCHAR) -> Self {
7750 let mut __bindgen_tmp = MaybeUninit::uninit();
7751 Metafile_Metafile2(__bindgen_tmp.as_mut_ptr(), filename);
7752 __bindgen_tmp.assume_init()
7753 }
7754 #[inline]
7755 pub unsafe fn new3(
7756 filename: *const WCHAR,
7757 wmfPlaceableFileHeader: *const WmfPlaceableFileHeader,
7758 ) -> Self {
7759 let mut __bindgen_tmp = MaybeUninit::uninit();
7760 Metafile_Metafile3(__bindgen_tmp.as_mut_ptr(), filename, wmfPlaceableFileHeader);
7761 __bindgen_tmp.assume_init()
7762 }
7763 #[inline]
7764 pub unsafe fn new4(stream: *mut IStream) -> Self {
7765 let mut __bindgen_tmp = MaybeUninit::uninit();
7766 Metafile_Metafile4(__bindgen_tmp.as_mut_ptr(), stream);
7767 __bindgen_tmp.assume_init()
7768 }
7769 #[inline]
7770 pub unsafe fn new5(referenceHdc: HDC, type_: EmfType, description: *const WCHAR) -> Self {
7771 let mut __bindgen_tmp = MaybeUninit::uninit();
7772 Metafile_Metafile5(__bindgen_tmp.as_mut_ptr(), referenceHdc, type_, description);
7773 __bindgen_tmp.assume_init()
7774 }
7775 #[inline]
7776 pub unsafe fn new6(
7777 referenceHdc: HDC,
7778 frameRect: *const RectF,
7779 frameUnit: MetafileFrameUnit,
7780 type_: EmfType,
7781 description: *const WCHAR,
7782 ) -> Self {
7783 let mut __bindgen_tmp = MaybeUninit::uninit();
7784 Metafile_Metafile6(
7785 __bindgen_tmp.as_mut_ptr(),
7786 referenceHdc,
7787 frameRect,
7788 frameUnit,
7789 type_,
7790 description,
7791 );
7792 __bindgen_tmp.assume_init()
7793 }
7794 #[inline]
7795 pub unsafe fn new7(
7796 referenceHdc: HDC,
7797 frameRect: *const Rect,
7798 frameUnit: MetafileFrameUnit,
7799 type_: EmfType,
7800 description: *const WCHAR,
7801 ) -> Self {
7802 let mut __bindgen_tmp = MaybeUninit::uninit();
7803 Metafile_Metafile7(
7804 __bindgen_tmp.as_mut_ptr(),
7805 referenceHdc,
7806 frameRect,
7807 frameUnit,
7808 type_,
7809 description,
7810 );
7811 __bindgen_tmp.assume_init()
7812 }
7813 #[inline]
7814 pub unsafe fn new8(
7815 fileName: *const WCHAR,
7816 referenceHdc: HDC,
7817 type_: EmfType,
7818 description: *const WCHAR,
7819 ) -> Self {
7820 let mut __bindgen_tmp = MaybeUninit::uninit();
7821 Metafile_Metafile8(
7822 __bindgen_tmp.as_mut_ptr(),
7823 fileName,
7824 referenceHdc,
7825 type_,
7826 description,
7827 );
7828 __bindgen_tmp.assume_init()
7829 }
7830 #[inline]
7831 pub unsafe fn new9(
7832 fileName: *const WCHAR,
7833 referenceHdc: HDC,
7834 frameRect: *const RectF,
7835 frameUnit: MetafileFrameUnit,
7836 type_: EmfType,
7837 description: *const WCHAR,
7838 ) -> Self {
7839 let mut __bindgen_tmp = MaybeUninit::uninit();
7840 Metafile_Metafile9(
7841 __bindgen_tmp.as_mut_ptr(),
7842 fileName,
7843 referenceHdc,
7844 frameRect,
7845 frameUnit,
7846 type_,
7847 description,
7848 );
7849 __bindgen_tmp.assume_init()
7850 }
7851 #[inline]
7852 pub unsafe fn new10(
7853 fileName: *const WCHAR,
7854 referenceHdc: HDC,
7855 frameRect: *const Rect,
7856 frameUnit: MetafileFrameUnit,
7857 type_: EmfType,
7858 description: *const WCHAR,
7859 ) -> Self {
7860 let mut __bindgen_tmp = MaybeUninit::uninit();
7861 Metafile_Metafile10(
7862 __bindgen_tmp.as_mut_ptr(),
7863 fileName,
7864 referenceHdc,
7865 frameRect,
7866 frameUnit,
7867 type_,
7868 description,
7869 );
7870 __bindgen_tmp.assume_init()
7871 }
7872 #[inline]
7873 pub unsafe fn new11(
7874 stream: *mut IStream,
7875 referenceHdc: HDC,
7876 type_: EmfType,
7877 description: *const WCHAR,
7878 ) -> Self {
7879 let mut __bindgen_tmp = MaybeUninit::uninit();
7880 Metafile_Metafile11(
7881 __bindgen_tmp.as_mut_ptr(),
7882 stream,
7883 referenceHdc,
7884 type_,
7885 description,
7886 );
7887 __bindgen_tmp.assume_init()
7888 }
7889 #[inline]
7890 pub unsafe fn new12(
7891 stream: *mut IStream,
7892 referenceHdc: HDC,
7893 frameRect: *const RectF,
7894 frameUnit: MetafileFrameUnit,
7895 type_: EmfType,
7896 description: *const WCHAR,
7897 ) -> Self {
7898 let mut __bindgen_tmp = MaybeUninit::uninit();
7899 Metafile_Metafile12(
7900 __bindgen_tmp.as_mut_ptr(),
7901 stream,
7902 referenceHdc,
7903 frameRect,
7904 frameUnit,
7905 type_,
7906 description,
7907 );
7908 __bindgen_tmp.assume_init()
7909 }
7910 #[inline]
7911 pub unsafe fn new13(
7912 stream: *mut IStream,
7913 referenceHdc: HDC,
7914 frameRect: *const Rect,
7915 frameUnit: MetafileFrameUnit,
7916 type_: EmfType,
7917 description: *const WCHAR,
7918 ) -> Self {
7919 let mut __bindgen_tmp = MaybeUninit::uninit();
7920 Metafile_Metafile13(
7921 __bindgen_tmp.as_mut_ptr(),
7922 stream,
7923 referenceHdc,
7924 frameRect,
7925 frameUnit,
7926 type_,
7927 description,
7928 );
7929 __bindgen_tmp.assume_init()
7930 }
7931}
7932#[repr(C)]
7933#[derive(Debug)]
7934pub struct Matrix {
7935 pub nativeMatrix: *mut GpMatrix,
7936 pub lastResult: Status,
7937}
7938#[repr(C)]
7939#[derive(Debug)]
7940pub struct Pen {
7941 pub nativePen: *mut GpPen,
7942 pub lastResult: Status,
7943}
7944#[repr(C)]
7945#[derive(Debug)]
7946pub struct StringFormat {
7947 pub nativeFormat: *mut GpStringFormat,
7948 pub lastError: Status,
7949}
7950extern "C" {
7951 #[link_name = "\u{1}?GenericDefault@StringFormat@Gdiplus@@SAPEBV12@XZ"]
7952 pub fn StringFormat_GenericDefault() -> *const StringFormat;
7953}
7954extern "C" {
7955 #[link_name = "\u{1}?GenericTypographic@StringFormat@Gdiplus@@SAPEBV12@XZ"]
7956 pub fn StringFormat_GenericTypographic() -> *const StringFormat;
7957}
7958impl StringFormat {
7959 #[inline]
7960 pub unsafe fn GenericDefault() -> *const StringFormat {
7961 StringFormat_GenericDefault()
7962 }
7963 #[inline]
7964 pub unsafe fn GenericTypographic() -> *const StringFormat {
7965 StringFormat_GenericTypographic()
7966 }
7967}
7968#[repr(C)]
7969#[derive(Debug)]
7970pub struct GraphicsPath {
7971 pub nativePath: *mut GpPath,
7972 pub lastResult: Status,
7973}
7974extern "C" {
7975 #[link_name = "\u{1}?GetBounds@GraphicsPath@Gdiplus@@QEBA?AW4Status@2@PEAVRectF@2@PEBVMatrix@2@PEBVPen@2@@Z"]
7976 pub fn GraphicsPath_GetBounds(
7977 this: *const GraphicsPath,
7978 bounds: *mut RectF,
7979 matrix: *const Matrix,
7980 pen: *const Pen,
7981 ) -> Status;
7982}
7983extern "C" {
7984 #[link_name = "\u{1}?GetBounds@GraphicsPath@Gdiplus@@QEBA?AW4Status@2@PEAVRect@2@PEBVMatrix@2@PEBVPen@2@@Z"]
7985 pub fn GraphicsPath_GetBounds1(
7986 this: *const GraphicsPath,
7987 bounds: *mut Rect,
7988 matrix: *const Matrix,
7989 pen: *const Pen,
7990 ) -> Status;
7991}
7992extern "C" {
7993 #[link_name = "\u{1}?IsVisible@GraphicsPath@Gdiplus@@QEBAHMMPEBVGraphics@2@@Z"]
7994 pub fn GraphicsPath_IsVisible(
7995 this: *const GraphicsPath,
7996 x: REAL,
7997 y: REAL,
7998 g: *const Graphics,
7999 ) -> BOOL;
8000}
8001extern "C" {
8002 #[link_name = "\u{1}?IsVisible@GraphicsPath@Gdiplus@@QEBAHHHPEBVGraphics@2@@Z"]
8003 pub fn GraphicsPath_IsVisible1(
8004 this: *const GraphicsPath,
8005 x: INT,
8006 y: INT,
8007 g: *const Graphics,
8008 ) -> BOOL;
8009}
8010extern "C" {
8011 #[link_name = "\u{1}?IsOutlineVisible@GraphicsPath@Gdiplus@@QEBAHMMPEBVPen@2@PEBVGraphics@2@@Z"]
8012 pub fn GraphicsPath_IsOutlineVisible(
8013 this: *const GraphicsPath,
8014 x: REAL,
8015 y: REAL,
8016 pen: *const Pen,
8017 g: *const Graphics,
8018 ) -> BOOL;
8019}
8020extern "C" {
8021 #[link_name = "\u{1}?IsOutlineVisible@GraphicsPath@Gdiplus@@QEBAHHHPEBVPen@2@PEBVGraphics@2@@Z"]
8022 pub fn GraphicsPath_IsOutlineVisible1(
8023 this: *const GraphicsPath,
8024 x: INT,
8025 y: INT,
8026 pen: *const Pen,
8027 g: *const Graphics,
8028 ) -> BOOL;
8029}
8030impl GraphicsPath {
8031 #[inline]
8032 pub unsafe fn GetBounds(
8033 &self,
8034 bounds: *mut RectF,
8035 matrix: *const Matrix,
8036 pen: *const Pen,
8037 ) -> Status {
8038 GraphicsPath_GetBounds(self, bounds, matrix, pen)
8039 }
8040 #[inline]
8041 pub unsafe fn GetBounds1(
8042 &self,
8043 bounds: *mut Rect,
8044 matrix: *const Matrix,
8045 pen: *const Pen,
8046 ) -> Status {
8047 GraphicsPath_GetBounds1(self, bounds, matrix, pen)
8048 }
8049 #[inline]
8050 pub unsafe fn IsVisible(&self, x: REAL, y: REAL, g: *const Graphics) -> BOOL {
8051 GraphicsPath_IsVisible(self, x, y, g)
8052 }
8053 #[inline]
8054 pub unsafe fn IsVisible1(&self, x: INT, y: INT, g: *const Graphics) -> BOOL {
8055 GraphicsPath_IsVisible1(self, x, y, g)
8056 }
8057 #[inline]
8058 pub unsafe fn IsOutlineVisible(
8059 &self,
8060 x: REAL,
8061 y: REAL,
8062 pen: *const Pen,
8063 g: *const Graphics,
8064 ) -> BOOL {
8065 GraphicsPath_IsOutlineVisible(self, x, y, pen, g)
8066 }
8067 #[inline]
8068 pub unsafe fn IsOutlineVisible1(
8069 &self,
8070 x: INT,
8071 y: INT,
8072 pen: *const Pen,
8073 g: *const Graphics,
8074 ) -> BOOL {
8075 GraphicsPath_IsOutlineVisible1(self, x, y, pen, g)
8076 }
8077}
8078#[repr(C)]
8079#[derive(Debug)]
8080pub struct Graphics {
8081 pub nativeGraphics: *mut GpGraphics,
8082 pub lastResult: Status,
8083}