1pub type va_list = __builtin_va_list;
4#[repr(u32)]
5#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6pub enum YGAlign {
7 YGAlignAuto = 0,
8 YGAlignFlexStart = 1,
9 YGAlignCenter = 2,
10 YGAlignFlexEnd = 3,
11 YGAlignStretch = 4,
12 YGAlignBaseline = 5,
13 YGAlignSpaceBetween = 6,
14 YGAlignSpaceAround = 7,
15}
16extern "C" {
17 pub fn YGAlignToString(value: YGAlign) -> *const ::std::os::raw::c_char;
18}
19#[repr(u32)]
20#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
21pub enum YGDimension {
22 YGDimensionWidth = 0,
23 YGDimensionHeight = 1,
24}
25extern "C" {
26 pub fn YGDimensionToString(value: YGDimension) -> *const ::std::os::raw::c_char;
27}
28#[repr(u32)]
29#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
30pub enum YGDirection {
31 YGDirectionInherit = 0,
32 YGDirectionLTR = 1,
33 YGDirectionRTL = 2,
34}
35extern "C" {
36 pub fn YGDirectionToString(value: YGDirection) -> *const ::std::os::raw::c_char;
37}
38#[repr(u32)]
39#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
40pub enum YGDisplay {
41 YGDisplayFlex = 0,
42 YGDisplayNone = 1,
43}
44extern "C" {
45 pub fn YGDisplayToString(value: YGDisplay) -> *const ::std::os::raw::c_char;
46}
47#[repr(u32)]
48#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
49pub enum YGEdge {
50 YGEdgeLeft = 0,
51 YGEdgeTop = 1,
52 YGEdgeRight = 2,
53 YGEdgeBottom = 3,
54 YGEdgeStart = 4,
55 YGEdgeEnd = 5,
56 YGEdgeHorizontal = 6,
57 YGEdgeVertical = 7,
58 YGEdgeAll = 8,
59}
60extern "C" {
61 pub fn YGEdgeToString(value: YGEdge) -> *const ::std::os::raw::c_char;
62}
63#[repr(u32)]
64#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
65pub enum YGExperimentalFeature {
66 YGExperimentalFeatureWebFlexBasis = 0,
67}
68extern "C" {
69 pub fn YGExperimentalFeatureToString(
70 value: YGExperimentalFeature,
71 ) -> *const ::std::os::raw::c_char;
72}
73#[repr(u32)]
74#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
75pub enum YGFlexDirection {
76 YGFlexDirectionColumn = 0,
77 YGFlexDirectionColumnReverse = 1,
78 YGFlexDirectionRow = 2,
79 YGFlexDirectionRowReverse = 3,
80}
81extern "C" {
82 pub fn YGFlexDirectionToString(value: YGFlexDirection) -> *const ::std::os::raw::c_char;
83}
84#[repr(u32)]
85#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
86pub enum YGJustify {
87 YGJustifyFlexStart = 0,
88 YGJustifyCenter = 1,
89 YGJustifyFlexEnd = 2,
90 YGJustifySpaceBetween = 3,
91 YGJustifySpaceAround = 4,
92}
93extern "C" {
94 pub fn YGJustifyToString(value: YGJustify) -> *const ::std::os::raw::c_char;
95}
96#[repr(u32)]
97#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
98pub enum YGLogLevel {
99 YGLogLevelError = 0,
100 YGLogLevelWarn = 1,
101 YGLogLevelInfo = 2,
102 YGLogLevelDebug = 3,
103 YGLogLevelVerbose = 4,
104 YGLogLevelFatal = 5,
105}
106extern "C" {
107 pub fn YGLogLevelToString(value: YGLogLevel) -> *const ::std::os::raw::c_char;
108}
109#[repr(u32)]
110#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
111pub enum YGMeasureMode {
112 YGMeasureModeUndefined = 0,
113 YGMeasureModeExactly = 1,
114 YGMeasureModeAtMost = 2,
115}
116extern "C" {
117 pub fn YGMeasureModeToString(value: YGMeasureMode) -> *const ::std::os::raw::c_char;
118}
119#[repr(u32)]
120#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
121pub enum YGNodeType {
122 YGNodeTypeDefault = 0,
123 YGNodeTypeText = 1,
124}
125extern "C" {
126 pub fn YGNodeTypeToString(value: YGNodeType) -> *const ::std::os::raw::c_char;
127}
128#[repr(u32)]
129#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
130pub enum YGOverflow {
131 YGOverflowVisible = 0,
132 YGOverflowHidden = 1,
133 YGOverflowScroll = 2,
134}
135extern "C" {
136 pub fn YGOverflowToString(value: YGOverflow) -> *const ::std::os::raw::c_char;
137}
138#[repr(u32)]
139#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
140pub enum YGPositionType {
141 YGPositionTypeRelative = 0,
142 YGPositionTypeAbsolute = 1,
143}
144extern "C" {
145 pub fn YGPositionTypeToString(value: YGPositionType) -> *const ::std::os::raw::c_char;
146}
147#[repr(u32)]
148#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
149pub enum YGPrintOptions {
150 YGPrintOptionsLayout = 1,
151 YGPrintOptionsStyle = 2,
152 YGPrintOptionsChildren = 4,
153}
154extern "C" {
155 pub fn YGPrintOptionsToString(value: YGPrintOptions) -> *const ::std::os::raw::c_char;
156}
157#[repr(u32)]
158#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
159pub enum YGUnit {
160 YGUnitUndefined = 0,
161 YGUnitPoint = 1,
162 YGUnitPercent = 2,
163 YGUnitAuto = 3,
164}
165extern "C" {
166 pub fn YGUnitToString(value: YGUnit) -> *const ::std::os::raw::c_char;
167}
168#[repr(u32)]
169#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
170pub enum YGWrap {
171 YGWrapNoWrap = 0,
172 YGWrapWrap = 1,
173 YGWrapWrapReverse = 2,
174}
175extern "C" {
176 pub fn YGWrapToString(value: YGWrap) -> *const ::std::os::raw::c_char;
177}
178#[repr(C)]
179#[derive(Debug, Copy, Clone)]
180pub struct YGSize {
181 pub width: f32,
182 pub height: f32,
183}
184#[test]
185fn bindgen_test_layout_YGSize() {
186 assert_eq!(
187 ::std::mem::size_of::<YGSize>(),
188 8usize,
189 concat!("Size of: ", stringify!(YGSize))
190 );
191 assert_eq!(
192 ::std::mem::align_of::<YGSize>(),
193 4usize,
194 concat!("Alignment of ", stringify!(YGSize))
195 );
196 assert_eq!(
197 unsafe { &(*(0 as *const YGSize)).width as *const _ as usize },
198 0usize,
199 concat!(
200 "Alignment of field: ",
201 stringify!(YGSize),
202 "::",
203 stringify!(width)
204 )
205 );
206 assert_eq!(
207 unsafe { &(*(0 as *const YGSize)).height as *const _ as usize },
208 4usize,
209 concat!(
210 "Alignment of field: ",
211 stringify!(YGSize),
212 "::",
213 stringify!(height)
214 )
215 );
216}
217#[repr(C)]
218#[derive(Debug, Copy, Clone)]
219pub struct YGValue {
220 pub value: f32,
221 pub unit: YGUnit,
222}
223#[test]
224fn bindgen_test_layout_YGValue() {
225 assert_eq!(
226 ::std::mem::size_of::<YGValue>(),
227 8usize,
228 concat!("Size of: ", stringify!(YGValue))
229 );
230 assert_eq!(
231 ::std::mem::align_of::<YGValue>(),
232 4usize,
233 concat!("Alignment of ", stringify!(YGValue))
234 );
235 assert_eq!(
236 unsafe { &(*(0 as *const YGValue)).value as *const _ as usize },
237 0usize,
238 concat!(
239 "Alignment of field: ",
240 stringify!(YGValue),
241 "::",
242 stringify!(value)
243 )
244 );
245 assert_eq!(
246 unsafe { &(*(0 as *const YGValue)).unit as *const _ as usize },
247 4usize,
248 concat!(
249 "Alignment of field: ",
250 stringify!(YGValue),
251 "::",
252 stringify!(unit)
253 )
254 );
255}
256#[repr(C)]
257#[derive(Debug, Copy, Clone)]
258pub struct YGConfig {
259 _unused: [u8; 0],
260}
261pub type YGConfigRef = *mut YGConfig;
262#[repr(C)]
263#[derive(Debug, Copy, Clone)]
264pub struct YGNode {
265 _unused: [u8; 0],
266}
267pub type YGNodeRef = *mut YGNode;
268pub type YGMeasureFunc = ::std::option::Option<
269 unsafe extern "C" fn(node: YGNodeRef,
270 width: f32,
271 widthMode: YGMeasureMode,
272 height: f32,
273 heightMode: YGMeasureMode)
274 -> YGSize,
275>;
276pub type YGBaselineFunc = ::std::option::Option<
277 unsafe extern "C" fn(node: YGNodeRef,
278 width: f32,
279 height: f32)
280 -> f32,
281>;
282pub type YGPrintFunc = ::std::option::Option<unsafe extern "C" fn(node: YGNodeRef)>;
283pub type YGLogger =
284 ::std::option::Option<
285 unsafe extern "C" fn(config: YGConfigRef,
286 node: YGNodeRef,
287 level: YGLogLevel,
288 format: *const ::std::os::raw::c_char,
289 args: *mut __va_list_tag)
290 -> ::std::os::raw::c_int,
291 >;
292pub type YGNodeClonedFunc =
293 ::std::option::Option<
294 unsafe extern "C" fn(oldNode: YGNodeRef,
295 newNode: YGNodeRef,
296 parent: YGNodeRef,
297 childIndex: ::std::os::raw::c_int),
298 >;
299extern "C" {
300 pub fn YGNodeNew() -> YGNodeRef;
301}
302extern "C" {
303 pub fn YGNodeNewWithConfig(config: YGConfigRef) -> YGNodeRef;
304}
305extern "C" {
306 pub fn YGNodeClone(node: YGNodeRef) -> YGNodeRef;
307}
308extern "C" {
309 pub fn YGNodeFree(node: YGNodeRef);
310}
311extern "C" {
312 pub fn YGNodeFreeRecursive(node: YGNodeRef);
313}
314extern "C" {
315 pub fn YGNodeReset(node: YGNodeRef);
316}
317extern "C" {
318 pub fn YGNodeGetInstanceCount() -> i32;
319}
320extern "C" {
321 pub fn YGNodeInsertChild(node: YGNodeRef, child: YGNodeRef, index: u32);
322}
323extern "C" {
324 pub fn YGNodeRemoveChild(node: YGNodeRef, child: YGNodeRef);
325}
326extern "C" {
327 pub fn YGNodeRemoveAllChildren(node: YGNodeRef);
328}
329extern "C" {
330 pub fn YGNodeGetChild(node: YGNodeRef, index: u32) -> YGNodeRef;
331}
332extern "C" {
333 pub fn YGNodeGetParent(node: YGNodeRef) -> YGNodeRef;
334}
335extern "C" {
336 pub fn YGNodeGetChildCount(node: YGNodeRef) -> u32;
337}
338extern "C" {
339 pub fn YGNodeCalculateLayout(
340 node: YGNodeRef,
341 availableWidth: f32,
342 availableHeight: f32,
343 parentDirection: YGDirection,
344 );
345}
346extern "C" {
347 pub fn YGNodeMarkDirty(node: YGNodeRef);
348}
349extern "C" {
350 pub fn YGNodeIsDirty(node: YGNodeRef) -> bool;
351}
352extern "C" {
353 pub fn YGNodePrint(node: YGNodeRef, options: YGPrintOptions);
354}
355extern "C" {
356 pub fn YGFloatIsUndefined(value: f32) -> bool;
357}
358extern "C" {
359 pub fn YGNodeCanUseCachedMeasurement(
360 widthMode: YGMeasureMode,
361 width: f32,
362 heightMode: YGMeasureMode,
363 height: f32,
364 lastWidthMode: YGMeasureMode,
365 lastWidth: f32,
366 lastHeightMode: YGMeasureMode,
367 lastHeight: f32,
368 lastComputedWidth: f32,
369 lastComputedHeight: f32,
370 marginRow: f32,
371 marginColumn: f32,
372 config: YGConfigRef,
373 ) -> bool;
374}
375extern "C" {
376 pub fn YGNodeCopyStyle(dstNode: YGNodeRef, srcNode: YGNodeRef);
377}
378extern "C" {
379 pub fn YGNodeSetContext(node: YGNodeRef, context: *mut ::std::os::raw::c_void);
380}
381extern "C" {
382 pub fn YGNodeGetContext(node: YGNodeRef) -> *mut ::std::os::raw::c_void;
383}
384extern "C" {
385 pub fn YGNodeSetMeasureFunc(node: YGNodeRef, measureFunc: YGMeasureFunc);
386}
387extern "C" {
388 pub fn YGNodeGetMeasureFunc(node: YGNodeRef) -> YGMeasureFunc;
389}
390extern "C" {
391 pub fn YGNodeSetBaselineFunc(node: YGNodeRef, baselineFunc: YGBaselineFunc);
392}
393extern "C" {
394 pub fn YGNodeGetBaselineFunc(node: YGNodeRef) -> YGBaselineFunc;
395}
396extern "C" {
397 pub fn YGNodeSetPrintFunc(node: YGNodeRef, printFunc: YGPrintFunc);
398}
399extern "C" {
400 pub fn YGNodeGetPrintFunc(node: YGNodeRef) -> YGPrintFunc;
401}
402extern "C" {
403 pub fn YGNodeSetHasNewLayout(node: YGNodeRef, hasNewLayout: bool);
404}
405extern "C" {
406 pub fn YGNodeGetHasNewLayout(node: YGNodeRef) -> bool;
407}
408extern "C" {
409 pub fn YGNodeSetNodeType(node: YGNodeRef, nodeType: YGNodeType);
410}
411extern "C" {
412 pub fn YGNodeGetNodeType(node: YGNodeRef) -> YGNodeType;
413}
414extern "C" {
415 pub fn YGNodeStyleSetDirection(node: YGNodeRef, direction: YGDirection);
416}
417extern "C" {
418 pub fn YGNodeStyleGetDirection(node: YGNodeRef) -> YGDirection;
419}
420extern "C" {
421 pub fn YGNodeStyleSetFlexDirection(node: YGNodeRef, flexDirection: YGFlexDirection);
422}
423extern "C" {
424 pub fn YGNodeStyleGetFlexDirection(node: YGNodeRef) -> YGFlexDirection;
425}
426extern "C" {
427 pub fn YGNodeStyleSetJustifyContent(node: YGNodeRef, justifyContent: YGJustify);
428}
429extern "C" {
430 pub fn YGNodeStyleGetJustifyContent(node: YGNodeRef) -> YGJustify;
431}
432extern "C" {
433 pub fn YGNodeStyleSetAlignContent(node: YGNodeRef, alignContent: YGAlign);
434}
435extern "C" {
436 pub fn YGNodeStyleGetAlignContent(node: YGNodeRef) -> YGAlign;
437}
438extern "C" {
439 pub fn YGNodeStyleSetAlignItems(node: YGNodeRef, alignItems: YGAlign);
440}
441extern "C" {
442 pub fn YGNodeStyleGetAlignItems(node: YGNodeRef) -> YGAlign;
443}
444extern "C" {
445 pub fn YGNodeStyleSetAlignSelf(node: YGNodeRef, alignSelf: YGAlign);
446}
447extern "C" {
448 pub fn YGNodeStyleGetAlignSelf(node: YGNodeRef) -> YGAlign;
449}
450extern "C" {
451 pub fn YGNodeStyleSetPositionType(node: YGNodeRef, positionType: YGPositionType);
452}
453extern "C" {
454 pub fn YGNodeStyleGetPositionType(node: YGNodeRef) -> YGPositionType;
455}
456extern "C" {
457 pub fn YGNodeStyleSetFlexWrap(node: YGNodeRef, flexWrap: YGWrap);
458}
459extern "C" {
460 pub fn YGNodeStyleGetFlexWrap(node: YGNodeRef) -> YGWrap;
461}
462extern "C" {
463 pub fn YGNodeStyleSetOverflow(node: YGNodeRef, overflow: YGOverflow);
464}
465extern "C" {
466 pub fn YGNodeStyleGetOverflow(node: YGNodeRef) -> YGOverflow;
467}
468extern "C" {
469 pub fn YGNodeStyleSetDisplay(node: YGNodeRef, display: YGDisplay);
470}
471extern "C" {
472 pub fn YGNodeStyleGetDisplay(node: YGNodeRef) -> YGDisplay;
473}
474extern "C" {
475 pub fn YGNodeStyleSetFlex(node: YGNodeRef, flex: f32);
476}
477extern "C" {
478 pub fn YGNodeStyleGetFlex(node: YGNodeRef) -> f32;
479}
480extern "C" {
481 pub fn YGNodeStyleSetFlexGrow(node: YGNodeRef, flexGrow: f32);
482}
483extern "C" {
484 pub fn YGNodeStyleGetFlexGrow(node: YGNodeRef) -> f32;
485}
486extern "C" {
487 pub fn YGNodeStyleSetFlexShrink(node: YGNodeRef, flexShrink: f32);
488}
489extern "C" {
490 pub fn YGNodeStyleGetFlexShrink(node: YGNodeRef) -> f32;
491}
492extern "C" {
493 pub fn YGNodeStyleSetFlexBasis(node: YGNodeRef, flexBasis: f32);
494}
495extern "C" {
496 pub fn YGNodeStyleSetFlexBasisPercent(node: YGNodeRef, flexBasis: f32);
497}
498extern "C" {
499 pub fn YGNodeStyleGetFlexBasis(node: YGNodeRef) -> YGValue;
500}
501extern "C" {
502 pub fn YGNodeStyleSetFlexBasisAuto(node: YGNodeRef);
503}
504extern "C" {
505 pub fn YGNodeStyleSetPosition(node: YGNodeRef, edge: YGEdge, position: f32);
506}
507extern "C" {
508 pub fn YGNodeStyleSetPositionPercent(node: YGNodeRef, edge: YGEdge, position: f32);
509}
510extern "C" {
511 pub fn YGNodeStyleGetPosition(node: YGNodeRef, edge: YGEdge) -> YGValue;
512}
513extern "C" {
514 pub fn YGNodeStyleSetMargin(node: YGNodeRef, edge: YGEdge, margin: f32);
515}
516extern "C" {
517 pub fn YGNodeStyleSetMarginPercent(node: YGNodeRef, edge: YGEdge, margin: f32);
518}
519extern "C" {
520 pub fn YGNodeStyleGetMargin(node: YGNodeRef, edge: YGEdge) -> YGValue;
521}
522extern "C" {
523 pub fn YGNodeStyleSetMarginAuto(node: YGNodeRef, edge: YGEdge);
524}
525extern "C" {
526 pub fn YGNodeStyleSetPadding(node: YGNodeRef, edge: YGEdge, padding: f32);
527}
528extern "C" {
529 pub fn YGNodeStyleSetPaddingPercent(node: YGNodeRef, edge: YGEdge, padding: f32);
530}
531extern "C" {
532 pub fn YGNodeStyleGetPadding(node: YGNodeRef, edge: YGEdge) -> YGValue;
533}
534extern "C" {
535 pub fn YGNodeStyleSetBorder(node: YGNodeRef, edge: YGEdge, border: f32);
536}
537extern "C" {
538 pub fn YGNodeStyleGetBorder(node: YGNodeRef, edge: YGEdge) -> f32;
539}
540extern "C" {
541 pub fn YGNodeStyleSetWidth(node: YGNodeRef, width: f32);
542}
543extern "C" {
544 pub fn YGNodeStyleSetWidthPercent(node: YGNodeRef, width: f32);
545}
546extern "C" {
547 pub fn YGNodeStyleGetWidth(node: YGNodeRef) -> YGValue;
548}
549extern "C" {
550 pub fn YGNodeStyleSetWidthAuto(node: YGNodeRef);
551}
552extern "C" {
553 pub fn YGNodeStyleSetHeight(node: YGNodeRef, height: f32);
554}
555extern "C" {
556 pub fn YGNodeStyleSetHeightPercent(node: YGNodeRef, height: f32);
557}
558extern "C" {
559 pub fn YGNodeStyleGetHeight(node: YGNodeRef) -> YGValue;
560}
561extern "C" {
562 pub fn YGNodeStyleSetHeightAuto(node: YGNodeRef);
563}
564extern "C" {
565 pub fn YGNodeStyleSetMinWidth(node: YGNodeRef, minWidth: f32);
566}
567extern "C" {
568 pub fn YGNodeStyleSetMinWidthPercent(node: YGNodeRef, minWidth: f32);
569}
570extern "C" {
571 pub fn YGNodeStyleGetMinWidth(node: YGNodeRef) -> YGValue;
572}
573extern "C" {
574 pub fn YGNodeStyleSetMinHeight(node: YGNodeRef, minHeight: f32);
575}
576extern "C" {
577 pub fn YGNodeStyleSetMinHeightPercent(node: YGNodeRef, minHeight: f32);
578}
579extern "C" {
580 pub fn YGNodeStyleGetMinHeight(node: YGNodeRef) -> YGValue;
581}
582extern "C" {
583 pub fn YGNodeStyleSetMaxWidth(node: YGNodeRef, maxWidth: f32);
584}
585extern "C" {
586 pub fn YGNodeStyleSetMaxWidthPercent(node: YGNodeRef, maxWidth: f32);
587}
588extern "C" {
589 pub fn YGNodeStyleGetMaxWidth(node: YGNodeRef) -> YGValue;
590}
591extern "C" {
592 pub fn YGNodeStyleSetMaxHeight(node: YGNodeRef, maxHeight: f32);
593}
594extern "C" {
595 pub fn YGNodeStyleSetMaxHeightPercent(node: YGNodeRef, maxHeight: f32);
596}
597extern "C" {
598 pub fn YGNodeStyleGetMaxHeight(node: YGNodeRef) -> YGValue;
599}
600extern "C" {
601 pub fn YGNodeStyleSetAspectRatio(node: YGNodeRef, aspectRatio: f32);
602}
603extern "C" {
604 pub fn YGNodeStyleGetAspectRatio(node: YGNodeRef) -> f32;
605}
606extern "C" {
607 pub fn YGNodeLayoutGetLeft(node: YGNodeRef) -> f32;
608}
609extern "C" {
610 pub fn YGNodeLayoutGetTop(node: YGNodeRef) -> f32;
611}
612extern "C" {
613 pub fn YGNodeLayoutGetRight(node: YGNodeRef) -> f32;
614}
615extern "C" {
616 pub fn YGNodeLayoutGetBottom(node: YGNodeRef) -> f32;
617}
618extern "C" {
619 pub fn YGNodeLayoutGetWidth(node: YGNodeRef) -> f32;
620}
621extern "C" {
622 pub fn YGNodeLayoutGetHeight(node: YGNodeRef) -> f32;
623}
624extern "C" {
625 pub fn YGNodeLayoutGetDirection(node: YGNodeRef) -> YGDirection;
626}
627extern "C" {
628 pub fn YGNodeLayoutGetHadOverflow(node: YGNodeRef) -> bool;
629}
630extern "C" {
631 pub fn YGNodeLayoutGetMargin(node: YGNodeRef, edge: YGEdge) -> f32;
632}
633extern "C" {
634 pub fn YGNodeLayoutGetBorder(node: YGNodeRef, edge: YGEdge) -> f32;
635}
636extern "C" {
637 pub fn YGNodeLayoutGetPadding(node: YGNodeRef, edge: YGEdge) -> f32;
638}
639extern "C" {
640 pub fn YGConfigSetLogger(config: YGConfigRef, logger: YGLogger);
641}
642extern "C" {
643 pub fn YGLog(node: YGNodeRef, level: YGLogLevel, message: *const ::std::os::raw::c_char, ...);
644}
645extern "C" {
646 pub fn YGLogWithConfig(
647 config: YGConfigRef,
648 level: YGLogLevel,
649 format: *const ::std::os::raw::c_char,
650 ...
651 );
652}
653extern "C" {
654 pub fn YGAssert(condition: bool, message: *const ::std::os::raw::c_char);
655}
656extern "C" {
657 pub fn YGAssertWithNode(
658 node: YGNodeRef,
659 condition: bool,
660 message: *const ::std::os::raw::c_char,
661 );
662}
663extern "C" {
664 pub fn YGAssertWithConfig(
665 config: YGConfigRef,
666 condition: bool,
667 message: *const ::std::os::raw::c_char,
668 );
669}
670extern "C" {
671 pub fn YGConfigSetPointScaleFactor(config: YGConfigRef, pixelsInPoint: f32);
672}
673extern "C" {
674 pub fn YGConfigSetUseLegacyStretchBehaviour(
675 config: YGConfigRef,
676 useLegacyStretchBehaviour: bool,
677 );
678}
679extern "C" {
680 pub fn YGConfigNew() -> YGConfigRef;
681}
682extern "C" {
683 pub fn YGConfigFree(config: YGConfigRef);
684}
685extern "C" {
686 pub fn YGConfigCopy(dest: YGConfigRef, src: YGConfigRef);
687}
688extern "C" {
689 pub fn YGConfigGetInstanceCount() -> i32;
690}
691extern "C" {
692 pub fn YGConfigSetExperimentalFeatureEnabled(
693 config: YGConfigRef,
694 feature: YGExperimentalFeature,
695 enabled: bool,
696 );
697}
698extern "C" {
699 pub fn YGConfigIsExperimentalFeatureEnabled(
700 config: YGConfigRef,
701 feature: YGExperimentalFeature,
702 ) -> bool;
703}
704extern "C" {
705 pub fn YGConfigSetUseWebDefaults(config: YGConfigRef, enabled: bool);
706}
707extern "C" {
708 pub fn YGConfigGetUseWebDefaults(config: YGConfigRef) -> bool;
709}
710extern "C" {
711 pub fn YGConfigSetNodeClonedFunc(config: YGConfigRef, callback: YGNodeClonedFunc);
712}
713extern "C" {
714 pub fn YGConfigGetDefault() -> YGConfigRef;
715}
716extern "C" {
717 pub fn YGConfigSetContext(config: YGConfigRef, context: *mut ::std::os::raw::c_void);
718}
719extern "C" {
720 pub fn YGConfigGetContext(config: YGConfigRef) -> *mut ::std::os::raw::c_void;
721}
722#[repr(C)]
723#[derive(Debug, Copy, Clone)]
724pub struct YGNodeList {
725 _unused: [u8; 0],
726}
727pub type YGNodeListRef = *mut YGNodeList;
728extern "C" {
729 pub fn YGNodeListNew(initialCapacity: u32) -> YGNodeListRef;
730}
731extern "C" {
732 pub fn YGNodeListFree(list: YGNodeListRef);
733}
734extern "C" {
735 pub fn YGNodeListCount(list: YGNodeListRef) -> u32;
736}
737extern "C" {
738 pub fn YGNodeListAdd(listp: *mut YGNodeListRef, node: YGNodeRef);
739}
740extern "C" {
741 pub fn YGNodeListInsert(listp: *mut YGNodeListRef, node: YGNodeRef, index: u32);
742}
743extern "C" {
744 pub fn YGNodeListReplace(list: YGNodeListRef, index: u32, newNode: YGNodeRef);
745}
746extern "C" {
747 pub fn YGNodeListRemoveAll(list: YGNodeListRef);
748}
749extern "C" {
750 pub fn YGNodeListRemove(list: YGNodeListRef, index: u32) -> YGNodeRef;
751}
752extern "C" {
753 pub fn YGNodeListDelete(list: YGNodeListRef, node: YGNodeRef) -> YGNodeRef;
754}
755extern "C" {
756 pub fn YGNodeListGet(list: YGNodeListRef, index: u32) -> YGNodeRef;
757}
758extern "C" {
759 pub fn YGNodeListClone(list: YGNodeListRef) -> YGNodeListRef;
760}
761pub type __builtin_va_list = [__va_list_tag; 1usize];
762#[repr(C)]
763#[derive(Debug, Copy, Clone)]
764pub struct __va_list_tag {
765 pub gp_offset: ::std::os::raw::c_uint,
766 pub fp_offset: ::std::os::raw::c_uint,
767 pub overflow_arg_area: *mut ::std::os::raw::c_void,
768 pub reg_save_area: *mut ::std::os::raw::c_void,
769}
770#[test]
771fn bindgen_test_layout___va_list_tag() {
772 assert_eq!(
773 ::std::mem::size_of::<__va_list_tag>(),
774 24usize,
775 concat!("Size of: ", stringify!(__va_list_tag))
776 );
777 assert_eq!(
778 ::std::mem::align_of::<__va_list_tag>(),
779 8usize,
780 concat!("Alignment of ", stringify!(__va_list_tag))
781 );
782 assert_eq!(
783 unsafe { &(*(0 as *const __va_list_tag)).gp_offset as *const _ as usize },
784 0usize,
785 concat!(
786 "Alignment of field: ",
787 stringify!(__va_list_tag),
788 "::",
789 stringify!(gp_offset)
790 )
791 );
792 assert_eq!(
793 unsafe { &(*(0 as *const __va_list_tag)).fp_offset as *const _ as usize },
794 4usize,
795 concat!(
796 "Alignment of field: ",
797 stringify!(__va_list_tag),
798 "::",
799 stringify!(fp_offset)
800 )
801 );
802 assert_eq!(
803 unsafe { &(*(0 as *const __va_list_tag)).overflow_arg_area as *const _ as usize },
804 8usize,
805 concat!(
806 "Alignment of field: ",
807 stringify!(__va_list_tag),
808 "::",
809 stringify!(overflow_arg_area)
810 )
811 );
812 assert_eq!(
813 unsafe { &(*(0 as *const __va_list_tag)).reg_save_area as *const _ as usize },
814 16usize,
815 concat!(
816 "Alignment of field: ",
817 stringify!(__va_list_tag),
818 "::",
819 stringify!(reg_save_area)
820 )
821 );
822}