dali-toolkit/third-party/facebook-flexbox/layout.c

   1 /**
   2  * Copyright (c) 2014, Facebook, Inc.
   3  * All rights reserved.
   4  *
   5  * This source code is licensed under the BSD-style license found in the
   6  * LICENSE file in the root directory of this source tree. An additional grant
   7  * of patent rights can be found in the PATENTS file in the same directory.
   8  */
   9
  10 #include <math.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 // in concatenated header, don't include Layout.h it's already at the top
  16 #ifndef CSS_LAYOUT_IMPLEMENTATION
  17 #include "layout.h"
  18 #endif
  19
  20 #ifdef _MSC_VER
  21 #include <float.h>
  22 #define isnan _isnan
  23
  24 /* define fmaxf if < VC12 */
  25 #if _MSC_VER < 1800
  26 __forceinline const float fmaxf(const float a, const float b) {
  27   return (a > b) ? a : b;
  28 }
  29 #endif
  30 #endif
  31
  32 bool isUndefined(float value) {
  33   return isnan(value);
  34 }
  35
  36 static bool eq(float a, float b) {
  37   if (isUndefined(a)) {
  38     return isUndefined(b);
  39   }
  40   return fabs(a - b) < 0.0001;
  41 }
  42
  43 void init_css_node(css_node_t *node) {
  44   node->style.align_items = CSS_ALIGN_STRETCH;
  45   node->style.align_content = CSS_ALIGN_FLEX_START;
  46
  47   node->style.direction = CSS_DIRECTION_INHERIT;
  48   node->style.flex_direction = CSS_FLEX_DIRECTION_COLUMN;
  49
  50   // Some of the fields default to undefined and not 0
  51   node->style.dimensions[CSS_WIDTH] = CSS_UNDEFINED;
  52   node->style.dimensions[CSS_HEIGHT] = CSS_UNDEFINED;
  53
  54   node->style.minDimensions[CSS_WIDTH] = CSS_UNDEFINED;
  55   node->style.minDimensions[CSS_HEIGHT] = CSS_UNDEFINED;
  56
  57   node->style.maxDimensions[CSS_WIDTH] = CSS_UNDEFINED;
  58   node->style.maxDimensions[CSS_HEIGHT] = CSS_UNDEFINED;
  59
  60   node->style.position[CSS_LEFT] = CSS_UNDEFINED;
  61   node->style.position[CSS_TOP] = CSS_UNDEFINED;
  62   node->style.position[CSS_RIGHT] = CSS_UNDEFINED;
  63   node->style.position[CSS_BOTTOM] = CSS_UNDEFINED;
  64
  65   node->style.margin[CSS_START] = CSS_UNDEFINED;
  66   node->style.margin[CSS_END] = CSS_UNDEFINED;
  67   node->style.padding[CSS_START] = CSS_UNDEFINED;
  68   node->style.padding[CSS_END] = CSS_UNDEFINED;
  69   node->style.border[CSS_START] = CSS_UNDEFINED;
  70   node->style.border[CSS_END] = CSS_UNDEFINED;
  71
  72   node->layout.dimensions[CSS_WIDTH] = CSS_UNDEFINED;
  73   node->layout.dimensions[CSS_HEIGHT] = CSS_UNDEFINED;
  74
  75   // Such that the comparison is always going to be false
  76   node->layout.last_requested_dimensions[CSS_WIDTH] = -1;
  77   node->layout.last_requested_dimensions[CSS_HEIGHT] = -1;
  78   node->layout.last_parent_max_width = -1;
  79   node->layout.last_parent_max_height = -1;
  80   node->layout.last_direction = (css_direction_t)-1;
  81   node->layout.should_update = true;
  82 }
  83
  84 css_node_t *new_css_node() {
  85   css_node_t *node = (css_node_t *)calloc(1, sizeof(*node));
  86   init_css_node(node);
  87   return node;
  88 }
  89
  90 void free_css_node(css_node_t *node) {
  91   free(node);
  92 }
  93
  94 static void indent(int n) {
  95   int i;
  96   for (i = 0; i < n; ++i) {
  97     printf("  ");
  98   }
  99 }
 100
 101 static void print_number_0(const char *str, float number) {
 102   if (!eq(number, 0)) {
 103     printf("%s: %g, ", str, number);
 104   }
 105 }
 106
 107 static void print_number_nan(const char *str, float number) {
 108   if (!isnan(number)) {
 109     printf("%s: %g, ", str, number);
 110   }
 111 }
 112
 113 static bool four_equal(float four[4]) {
 114   return
 115     eq(four[0], four[1]) &&
 116     eq(four[0], four[2]) &&
 117     eq(four[0], four[3]);
 118 }
 119
 120
 121 static void print_css_node_rec(
 122   css_node_t *node,
 123   css_print_options_t options,
 124   int level
 125 ) {
 126   indent(level);
 127   printf("{");
 128
 129   if (node->print) {
 130     node->print(node->context);
 131   }
 132
 133   if (options & CSS_PRINT_LAYOUT) {
 134     printf("layout: {");
 135     printf("width: %g, ", node->layout.dimensions[CSS_WIDTH]);
 136     printf("height: %g, ", node->layout.dimensions[CSS_HEIGHT]);
 137     printf("top: %g, ", node->layout.position[CSS_TOP]);
 138     printf("left: %g", node->layout.position[CSS_LEFT]);
 139     printf("}, ");
 140   }
 141
 142   if (options & CSS_PRINT_STYLE) {
 143     if (node->style.direction == CSS_DIRECTION_INHERIT) {
 144       printf("direction: 'inherit', ");
 145     } else if (node->style.direction == CSS_DIRECTION_LTR) {
 146       printf("direction: 'LTR', ");
 147     } else if (node->style.direction == CSS_DIRECTION_RTL) {
 148       printf("direction: 'RTL', ");
 149     }
 150
 151     if (node->style.flex_direction == CSS_FLEX_DIRECTION_COLUMN) {
 152       printf("flexDirection: 'column', ");
 153     } else if (node->style.flex_direction == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
 154       printf("flexDirection: 'columnReverse', ");
 155     } else if (node->style.flex_direction == CSS_FLEX_DIRECTION_ROW) {
 156       printf("flexDirection: 'row', ");
 157     } else if (node->style.flex_direction == CSS_FLEX_DIRECTION_ROW_REVERSE) {
 158       printf("flexDirection: 'rowReverse', ");
 159     }
 160
 161     if (node->style.justify_content == CSS_JUSTIFY_FLEX_START) {
 162       printf("justifyContent: 'flex-start', ");
 163     } else if (node->style.justify_content == CSS_JUSTIFY_CENTER) {
 164       printf("justifyContent: 'center', ");
 165     } else if (node->style.justify_content == CSS_JUSTIFY_FLEX_END) {
 166       printf("justifyContent: 'flex-end', ");
 167     } else if (node->style.justify_content == CSS_JUSTIFY_SPACE_AROUND) {
 168       printf("justifyContent: 'space-around', ");
 169     } else if (node->style.justify_content == CSS_JUSTIFY_SPACE_BETWEEN) {
 170       printf("justifyContent: 'space-between', ");
 171     }
 172
 173     if (node->style.align_items == CSS_ALIGN_FLEX_START) {
 174       printf("alignItems: 'flex-start', ");
 175     } else if (node->style.align_items == CSS_ALIGN_CENTER) {
 176       printf("alignItems: 'center', ");
 177     } else if (node->style.align_items == CSS_ALIGN_FLEX_END) {
 178       printf("alignItems: 'flex-end', ");
 179     } else if (node->style.align_items == CSS_ALIGN_STRETCH) {
 180       printf("alignItems: 'stretch', ");
 181     }
 182
 183     if (node->style.align_content == CSS_ALIGN_FLEX_START) {
 184       printf("alignContent: 'flex-start', ");
 185     } else if (node->style.align_content == CSS_ALIGN_CENTER) {
 186       printf("alignContent: 'center', ");
 187     } else if (node->style.align_content == CSS_ALIGN_FLEX_END) {
 188       printf("alignContent: 'flex-end', ");
 189     } else if (node->style.align_content == CSS_ALIGN_STRETCH) {
 190       printf("alignContent: 'stretch', ");
 191     }
 192
 193     if (node->style.align_self == CSS_ALIGN_FLEX_START) {
 194       printf("alignSelf: 'flex-start', ");
 195     } else if (node->style.align_self == CSS_ALIGN_CENTER) {
 196       printf("alignSelf: 'center', ");
 197     } else if (node->style.align_self == CSS_ALIGN_FLEX_END) {
 198       printf("alignSelf: 'flex-end', ");
 199     } else if (node->style.align_self == CSS_ALIGN_STRETCH) {
 200       printf("alignSelf: 'stretch', ");
 201     } else if (node->style.align_self == CSS_ALIGN_AUTO) {
 202       printf("alignSelf: 'auto', ");
 203     }
 204
 205     if (node->style.flex_wrap == CSS_NOWRAP) {
 206       printf("flexWrap: 'no-wrap', ");
 207     } else if (node->style.flex_wrap == CSS_WRAP) {
 208       printf("flexWrap: 'wrap', ");
 209     }
 210
 211     print_number_nan("flex", node->style.flex);
 212
 213     if (four_equal(node->style.margin)) {
 214       print_number_0("margin", node->style.margin[CSS_LEFT]);
 215     } else {
 216       print_number_0("marginLeft", node->style.margin[CSS_LEFT]);
 217       print_number_0("marginRight", node->style.margin[CSS_RIGHT]);
 218       print_number_0("marginTop", node->style.margin[CSS_TOP]);
 219       print_number_0("marginBottom", node->style.margin[CSS_BOTTOM]);
 220       print_number_0("marginStart", node->style.margin[CSS_START]);
 221       print_number_0("marginEnd", node->style.margin[CSS_END]);
 222     }
 223
 224     if (four_equal(node->style.padding)) {
 225       print_number_0("padding", node->style.margin[CSS_LEFT]);
 226     } else {
 227       print_number_0("paddingLeft", node->style.padding[CSS_LEFT]);
 228       print_number_0("paddingRight", node->style.padding[CSS_RIGHT]);
 229       print_number_0("paddingTop", node->style.padding[CSS_TOP]);
 230       print_number_0("paddingBottom", node->style.padding[CSS_BOTTOM]);
 231       print_number_0("paddingStart", node->style.padding[CSS_START]);
 232       print_number_0("paddingEnd", node->style.padding[CSS_END]);
 233     }
 234
 235     if (four_equal(node->style.border)) {
 236       print_number_0("borderWidth", node->style.border[CSS_LEFT]);
 237     } else {
 238       print_number_0("borderLeftWidth", node->style.border[CSS_LEFT]);
 239       print_number_0("borderRightWidth", node->style.border[CSS_RIGHT]);
 240       print_number_0("borderTopWidth", node->style.border[CSS_TOP]);
 241       print_number_0("borderBottomWidth", node->style.border[CSS_BOTTOM]);
 242       print_number_0("borderStartWidth", node->style.border[CSS_START]);
 243       print_number_0("borderEndWidth", node->style.border[CSS_END]);
 244     }
 245
 246     print_number_nan("width", node->style.dimensions[CSS_WIDTH]);
 247     print_number_nan("height", node->style.dimensions[CSS_HEIGHT]);
 248
 249     if(node->style.minDimensions[CSS_WIDTH] != CSS_UNDEFINED) {
 250       print_number_nan("minWidth", node->style.minDimensions[CSS_WIDTH]);
 251     }
 252     if(node->style.minDimensions[CSS_HEIGHT] != CSS_UNDEFINED) {
 253       print_number_nan("minHeight", node->style.minDimensions[CSS_HEIGHT]);
 254     }
 255     if(node->style.maxDimensions[CSS_WIDTH] != CSS_UNDEFINED) {
 256       print_number_nan("maxWidth", node->style.maxDimensions[CSS_WIDTH]);
 257     }
 258     if(node->style.maxDimensions[CSS_HEIGHT] != CSS_UNDEFINED) {
 259       print_number_nan("maxHeight", node->style.maxDimensions[CSS_HEIGHT]);
 260     }
 261
 262     if (node->style.position_type == CSS_POSITION_ABSOLUTE) {
 263       printf("position: 'absolute', ");
 264     }
 265     else if (node->style.position_type == CSS_POSITION_RELATIVE) {
 266       printf("position: 'relative', ");
 267     }
 268
 269     print_number_nan("position-left", node->style.position[CSS_LEFT]);
 270     print_number_nan("position-right", node->style.position[CSS_RIGHT]);
 271     print_number_nan("position-top", node->style.position[CSS_TOP]);
 272     print_number_nan("position-bottom", node->style.position[CSS_BOTTOM]);
 273   }
 274
 275   if (options & CSS_PRINT_CHILDREN && node->children_count > 0) {
 276     printf("children: [\n");
 277     int i;
 278     for (i = 0; i < node->children_count; ++i) {
 279       print_css_node_rec(node->get_child(node->context, i), options, level + 1);
 280     }
 281     indent(level);
 282     printf("]},\n");
 283   } else {
 284     printf("},\n");
 285   }
 286 }
 287
 288 void print_css_node(css_node_t *node, css_print_options_t options) {
 289   print_css_node_rec(node, options, 0);
 290 }
 291
 292
 293 static css_position_t leading[4] = {
 294   /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_TOP,
 295   /* CSS_FLEX_DIRECTION_COLUMN_REVERSE = */ CSS_BOTTOM,
 296   /* CSS_FLEX_DIRECTION_ROW = */ CSS_LEFT,
 297   /* CSS_FLEX_DIRECTION_ROW_REVERSE = */ CSS_RIGHT
 298 };
 299 static css_position_t trailing[4] = {
 300   /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_BOTTOM,
 301   /* CSS_FLEX_DIRECTION_COLUMN_REVERSE = */ CSS_TOP,
 302   /* CSS_FLEX_DIRECTION_ROW = */ CSS_RIGHT,
 303   /* CSS_FLEX_DIRECTION_ROW_REVERSE = */ CSS_LEFT
 304 };
 305 static css_position_t pos[4] = {
 306   /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_TOP,
 307   /* CSS_FLEX_DIRECTION_COLUMN_REVERSE = */ CSS_BOTTOM,
 308   /* CSS_FLEX_DIRECTION_ROW = */ CSS_LEFT,
 309   /* CSS_FLEX_DIRECTION_ROW_REVERSE = */ CSS_RIGHT
 310 };
 311 static css_dimension_t dim[4] = {
 312   /* CSS_FLEX_DIRECTION_COLUMN = */ CSS_HEIGHT,
 313   /* CSS_FLEX_DIRECTION_COLUMN_REVERSE = */ CSS_HEIGHT,
 314   /* CSS_FLEX_DIRECTION_ROW = */ CSS_WIDTH,
 315   /* CSS_FLEX_DIRECTION_ROW_REVERSE = */ CSS_WIDTH
 316 };
 317
 318 static bool isRowDirection(css_flex_direction_t flex_direction) {
 319   return flex_direction == CSS_FLEX_DIRECTION_ROW ||
 320          flex_direction == CSS_FLEX_DIRECTION_ROW_REVERSE;
 321 }
 322
 323 static bool isColumnDirection(css_flex_direction_t flex_direction) {
 324   return flex_direction == CSS_FLEX_DIRECTION_COLUMN ||
 325          flex_direction == CSS_FLEX_DIRECTION_COLUMN_REVERSE;
 326 }
 327
 328 static float getLeadingMargin(css_node_t *node, css_flex_direction_t axis) {
 329   if (isRowDirection(axis) && !isUndefined(node->style.margin[CSS_START])) {
 330     return node->style.margin[CSS_START];
 331   }
 332
 333   return node->style.margin[leading[axis]];
 334 }
 335
 336 static float getTrailingMargin(css_node_t *node, css_flex_direction_t axis) {
 337   if (isRowDirection(axis) && !isUndefined(node->style.margin[CSS_END])) {
 338     return node->style.margin[CSS_END];
 339   }
 340
 341   return node->style.margin[trailing[axis]];
 342 }
 343
 344 static float getLeadingPadding(css_node_t *node, css_flex_direction_t axis) {
 345   if (isRowDirection(axis) &&
 346       !isUndefined(node->style.padding[CSS_START]) &&
 347       node->style.padding[CSS_START] >= 0) {
 348     return node->style.padding[CSS_START];
 349   }
 350
 351   if (node->style.padding[leading[axis]] >= 0) {
 352     return node->style.padding[leading[axis]];
 353   }
 354
 355   return 0;
 356 }
 357
 358 static float getTrailingPadding(css_node_t *node, css_flex_direction_t axis) {
 359   if (isRowDirection(axis) &&
 360       !isUndefined(node->style.padding[CSS_END]) &&
 361       node->style.padding[CSS_END] >= 0) {
 362     return node->style.padding[CSS_END];
 363   }
 364
 365   if (node->style.padding[trailing[axis]] >= 0) {
 366     return node->style.padding[trailing[axis]];
 367   }
 368
 369   return 0;
 370 }
 371
 372 static float getLeadingBorder(css_node_t *node, css_flex_direction_t axis) {
 373   if (isRowDirection(axis) &&
 374       !isUndefined(node->style.border[CSS_START]) &&
 375       node->style.border[CSS_START] >= 0) {
 376     return node->style.border[CSS_START];
 377   }
 378
 379   if (node->style.border[leading[axis]] >= 0) {
 380     return node->style.border[leading[axis]];
 381   }
 382
 383   return 0;
 384 }
 385
 386 static float getTrailingBorder(css_node_t *node, css_flex_direction_t axis) {
 387   if (isRowDirection(axis) &&
 388       !isUndefined(node->style.border[CSS_END]) &&
 389       node->style.border[CSS_END] >= 0) {
 390     return node->style.border[CSS_END];
 391   }
 392
 393   if (node->style.border[trailing[axis]] >= 0) {
 394     return node->style.border[trailing[axis]];
 395   }
 396
 397   return 0;
 398 }
 399
 400 static float getLeadingPaddingAndBorder(css_node_t *node, css_flex_direction_t axis) {
 401   return getLeadingPadding(node, axis) + getLeadingBorder(node, axis);
 402 }
 403
 404 static float getTrailingPaddingAndBorder(css_node_t *node, css_flex_direction_t axis) {
 405   return getTrailingPadding(node, axis) + getTrailingBorder(node, axis);
 406 }
 407
 408 static float getBorderAxis(css_node_t *node, css_flex_direction_t axis) {
 409   return getLeadingBorder(node, axis) + getTrailingBorder(node, axis);
 410 }
 411
 412 static float getMarginAxis(css_node_t *node, css_flex_direction_t axis) {
 413   return getLeadingMargin(node, axis) + getTrailingMargin(node, axis);
 414 }
 415
 416 static float getPaddingAndBorderAxis(css_node_t *node, css_flex_direction_t axis) {
 417   return getLeadingPaddingAndBorder(node, axis) + getTrailingPaddingAndBorder(node, axis);
 418 }
 419
 420 static css_align_t getAlignItem(css_node_t *node, css_node_t *child) {
 421   if (child->style.align_self != CSS_ALIGN_AUTO) {
 422     return child->style.align_self;
 423   }
 424   return node->style.align_items;
 425 }
 426
 427 static css_direction_t resolveDirection(css_node_t *node, css_direction_t parentDirection) {
 428   css_direction_t direction = node->style.direction;
 429
 430   if (direction == CSS_DIRECTION_INHERIT) {
 431     direction = parentDirection > CSS_DIRECTION_INHERIT ? parentDirection : CSS_DIRECTION_LTR;
 432   }
 433
 434   return direction;
 435 }
 436
 437 static css_flex_direction_t getFlexDirection(css_node_t *node) {
 438   return node->style.flex_direction;
 439 }
 440
 441 static css_flex_direction_t resolveAxis(css_flex_direction_t flex_direction, css_direction_t direction) {
 442   if (direction == CSS_DIRECTION_RTL) {
 443     if (flex_direction == CSS_FLEX_DIRECTION_ROW) {
 444       return CSS_FLEX_DIRECTION_ROW_REVERSE;
 445     } else if (flex_direction == CSS_FLEX_DIRECTION_ROW_REVERSE) {
 446       return CSS_FLEX_DIRECTION_ROW;
 447     }
 448   }
 449
 450   return flex_direction;
 451 }
 452
 453 static css_flex_direction_t getCrossFlexDirection(css_flex_direction_t flex_direction, css_direction_t direction) {
 454   if (isColumnDirection(flex_direction)) {
 455     return resolveAxis(CSS_FLEX_DIRECTION_ROW, direction);
 456   } else {
 457     return CSS_FLEX_DIRECTION_COLUMN;
 458   }
 459 }
 460
 461 static float getFlex(css_node_t *node) {
 462   return node->style.flex;
 463 }
 464
 465 static bool isFlex(css_node_t *node) {
 466   return (
 467     node->style.position_type == CSS_POSITION_RELATIVE &&
 468     getFlex(node) > 0
 469   );
 470 }
 471
 472 static bool isFlexWrap(css_node_t *node) {
 473   return node->style.flex_wrap == CSS_WRAP;
 474 }
 475
 476 static float getDimWithMargin(css_node_t *node, css_flex_direction_t axis) {
 477   return node->layout.dimensions[dim[axis]] +
 478     getLeadingMargin(node, axis) +
 479     getTrailingMargin(node, axis);
 480 }
 481
 482 static bool isStyleDimDefined(css_node_t *node, css_flex_direction_t axis) {
 483   float value = node->style.dimensions[dim[axis]];
 484   return !isUndefined(value) && value >= 0.0;
 485 }
 486
 487 static bool isLayoutDimDefined(css_node_t *node, css_flex_direction_t axis) {
 488   float value = node->layout.dimensions[dim[axis]];
 489   return !isUndefined(value) && value >= 0.0;
 490 }
 491
 492 static bool isPosDefined(css_node_t *node, css_position_t position) {
 493   return !isUndefined(node->style.position[position]);
 494 }
 495
 496 static bool isMeasureDefined(css_node_t *node) {
 497   return node->measure;
 498 }
 499
 500 static float getPosition(css_node_t *node, css_position_t position) {
 501   float result = node->style.position[position];
 502   if (!isUndefined(result)) {
 503     return result;
 504   }
 505   return 0;
 506 }
 507
 508 static float boundAxis(css_node_t *node, css_flex_direction_t axis, float value) {
 509   float min = CSS_UNDEFINED;
 510   float max = CSS_UNDEFINED;
 511
 512   if (isColumnDirection(axis)) {
 513     min = node->style.minDimensions[CSS_HEIGHT];
 514     max = node->style.maxDimensions[CSS_HEIGHT];
 515   } else if (isRowDirection(axis)) {
 516     min = node->style.minDimensions[CSS_WIDTH];
 517     max = node->style.maxDimensions[CSS_WIDTH];
 518   }
 519
 520   float boundValue = value;
 521
 522   if (!isUndefined(max) && max >= 0.0 && boundValue > max) {
 523     boundValue = max;
 524   }
 525   if (!isUndefined(min) && min >= 0.0 && boundValue < min) {
 526     boundValue = min;
 527   }
 528
 529   return boundValue;
 530 }
 531
 532 // When the user specifically sets a value for width or height
 533 static void setDimensionFromStyle(css_node_t *node, css_flex_direction_t axis) {
 534   // The parent already computed us a width or height. We just skip it
 535   if (isLayoutDimDefined(node, axis)) {
 536     return;
 537   }
 538   // We only run if there's a width or height defined
 539   if (!isStyleDimDefined(node, axis)) {
 540     return;
 541   }
 542
 543   // The dimensions can never be smaller than the padding and border
 544   node->layout.dimensions[dim[axis]] = fmaxf(
 545     boundAxis(node, axis, node->style.dimensions[dim[axis]]),
 546     getPaddingAndBorderAxis(node, axis)
 547   );
 548 }
 549
 550 static void setTrailingPosition(css_node_t *node, css_node_t *child, css_flex_direction_t axis) {
 551     child->layout.position[trailing[axis]] = node->layout.dimensions[dim[axis]] -
 552       child->layout.dimensions[dim[axis]] - child->layout.position[pos[axis]];
 553   }
 554
 555 // If both left and right are defined, then use left. Otherwise return
 556 // +left or -right depending on which is defined.
 557 static float getRelativePosition(css_node_t *node, css_flex_direction_t axis) {
 558   float lead = node->style.position[leading[axis]];
 559   if (!isUndefined(lead)) {
 560     return lead;
 561   }
 562   return -getPosition(node, trailing[axis]);
 563 }
 564
 565 static void layoutNodeImpl(css_node_t *node, float parentMaxWidth, float parentMaxHeight, css_direction_t parentDirection) {
 566   /** START_GENERATED **/
 567   css_direction_t direction = resolveDirection(node, parentDirection);
 568   css_flex_direction_t mainAxis = resolveAxis(getFlexDirection(node), direction);
 569   css_flex_direction_t crossAxis = getCrossFlexDirection(mainAxis, direction);
 570   css_flex_direction_t resolvedRowAxis = resolveAxis(CSS_FLEX_DIRECTION_ROW, direction);
 571
 572   // Handle width and height style attributes
 573   setDimensionFromStyle(node, mainAxis);
 574   setDimensionFromStyle(node, crossAxis);
 575
 576   // Set the resolved resolution in the node's layout
 577   node->layout.direction = direction;
 578
 579   // The position is set by the parent, but we need to complete it with a
 580   // delta composed of the margin and left/top/right/bottom
 581   node->layout.position[leading[mainAxis]] += getLeadingMargin(node, mainAxis) +
 582     getRelativePosition(node, mainAxis);
 583   node->layout.position[trailing[mainAxis]] += getTrailingMargin(node, mainAxis) +
 584     getRelativePosition(node, mainAxis);
 585   node->layout.position[leading[crossAxis]] += getLeadingMargin(node, crossAxis) +
 586     getRelativePosition(node, crossAxis);
 587   node->layout.position[trailing[crossAxis]] += getTrailingMargin(node, crossAxis) +
 588     getRelativePosition(node, crossAxis);
 589
 590   // Inline immutable values from the target node to avoid excessive method
 591   // invocations during the layout calculation.
 592   int childCount = node->children_count;
 593   float paddingAndBorderAxisResolvedRow = getPaddingAndBorderAxis(node, resolvedRowAxis);
 594   float paddingAndBorderAxisColumn = getPaddingAndBorderAxis(node, CSS_FLEX_DIRECTION_COLUMN);
 595
 596   if (isMeasureDefined(node)) {
 597     bool isResolvedRowDimDefined = isLayoutDimDefined(node, resolvedRowAxis);
 598
 599     float width = CSS_UNDEFINED;
 600     css_measure_mode_t widthMode = CSS_MEASURE_MODE_UNDEFINED;
 601     if (isStyleDimDefined(node, resolvedRowAxis)) {
 602       width = node->style.dimensions[CSS_WIDTH];
 603       widthMode = CSS_MEASURE_MODE_EXACTLY;
 604     } else if (isResolvedRowDimDefined) {
 605       width = node->layout.dimensions[dim[resolvedRowAxis]];
 606       widthMode = CSS_MEASURE_MODE_EXACTLY;
 607     } else {
 608       width = parentMaxWidth -
 609         getMarginAxis(node, resolvedRowAxis);
 610       widthMode = CSS_MEASURE_MODE_AT_MOST;
 611     }
 612     width -= paddingAndBorderAxisResolvedRow;
 613     if (isUndefined(width)) {
 614       widthMode = CSS_MEASURE_MODE_UNDEFINED;
 615     }
 616
 617     float height = CSS_UNDEFINED;
 618     css_measure_mode_t heightMode = CSS_MEASURE_MODE_UNDEFINED;
 619     if (isStyleDimDefined(node, CSS_FLEX_DIRECTION_COLUMN)) {
 620       height = node->style.dimensions[CSS_HEIGHT];
 621       heightMode = CSS_MEASURE_MODE_EXACTLY;
 622     } else if (isLayoutDimDefined(node, CSS_FLEX_DIRECTION_COLUMN)) {
 623       height = node->layout.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]];
 624       heightMode = CSS_MEASURE_MODE_EXACTLY;
 625     } else {
 626       height = parentMaxHeight -
 627         getMarginAxis(node, resolvedRowAxis);
 628       heightMode = CSS_MEASURE_MODE_AT_MOST;
 629     }
 630     height -= getPaddingAndBorderAxis(node, CSS_FLEX_DIRECTION_COLUMN);
 631     if (isUndefined(height)) {
 632       heightMode = CSS_MEASURE_MODE_UNDEFINED;
 633     }
 634
 635     // We only need to give a dimension for the text if we haven't got any
 636     // for it computed yet. It can either be from the style attribute or because
 637     // the element is flexible.
 638     bool isRowUndefined = !isStyleDimDefined(node, resolvedRowAxis) && !isResolvedRowDimDefined;
 639     bool isColumnUndefined = !isStyleDimDefined(node, CSS_FLEX_DIRECTION_COLUMN) &&
 640       isUndefined(node->layout.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]]);
 641
 642     // Let's not measure the text if we already know both dimensions
 643     if (isRowUndefined || isColumnUndefined) {
 644       css_dim_t measureDim = node->measure(
 645         node->context,
 646         width,
 647         widthMode,
 648         height,
 649         heightMode
 650       );
 651       if (isRowUndefined) {
 652         node->layout.dimensions[CSS_WIDTH] = measureDim.dimensions[CSS_WIDTH] +
 653           paddingAndBorderAxisResolvedRow;
 654       }
 655       if (isColumnUndefined) {
 656         node->layout.dimensions[CSS_HEIGHT] = measureDim.dimensions[CSS_HEIGHT] +
 657           paddingAndBorderAxisColumn;
 658       }
 659     }
 660     if (childCount == 0) {
 661       return;
 662     }
 663   }
 664
 665   bool isNodeFlexWrap = isFlexWrap(node);
 666
 667   css_justify_t justifyContent = node->style.justify_content;
 668
 669   float leadingPaddingAndBorderMain = getLeadingPaddingAndBorder(node, mainAxis);
 670   float leadingPaddingAndBorderCross = getLeadingPaddingAndBorder(node, crossAxis);
 671   float paddingAndBorderAxisMain = getPaddingAndBorderAxis(node, mainAxis);
 672   float paddingAndBorderAxisCross = getPaddingAndBorderAxis(node, crossAxis);
 673
 674   bool isMainDimDefined = isLayoutDimDefined(node, mainAxis);
 675   bool isCrossDimDefined = isLayoutDimDefined(node, crossAxis);
 676   bool isMainRowDirection = isRowDirection(mainAxis);
 677
 678   int i;
 679   int ii;
 680   css_node_t* child;
 681   css_flex_direction_t axis;
 682
 683   css_node_t* firstAbsoluteChild = NULL;
 684   css_node_t* currentAbsoluteChild = NULL;
 685
 686   float definedMainDim = CSS_UNDEFINED;
 687   if (isMainDimDefined) {
 688     definedMainDim = node->layout.dimensions[dim[mainAxis]] - paddingAndBorderAxisMain;
 689   }
 690
 691   // We want to execute the next two loops one per line with flex-wrap
 692   int startLine = 0;
 693   int endLine = 0;
 694   // int nextOffset = 0;
 695   int alreadyComputedNextLayout = 0;
 696   // We aggregate the total dimensions of the container in those two variables
 697   float linesCrossDim = 0;
 698   float linesMainDim = 0;
 699   int linesCount = 0;
 700   while (endLine < childCount) {
 701     // <Loop A> Layout non flexible children and count children by type
 702
 703     // mainContentDim is accumulation of the dimensions and margin of all the
 704     // non flexible children. This will be used in order to either set the
 705     // dimensions of the node if none already exist, or to compute the
 706     // remaining space left for the flexible children.
 707     float mainContentDim = 0;
 708
 709     // There are three kind of children, non flexible, flexible and absolute.
 710     // We need to know how many there are in order to distribute the space.
 711     int flexibleChildrenCount = 0;
 712     float totalFlexible = 0;
 713     int nonFlexibleChildrenCount = 0;
 714
 715     // Use the line loop to position children in the main axis for as long
 716     // as they are using a simple stacking behaviour. Children that are
 717     // immediately stacked in the initial loop will not be touched again
 718     // in <Loop C>.
 719     bool isSimpleStackMain =
 720         (isMainDimDefined && justifyContent == CSS_JUSTIFY_FLEX_START) ||
 721         (!isMainDimDefined && justifyContent != CSS_JUSTIFY_CENTER);
 722     int firstComplexMain = (isSimpleStackMain ? childCount : startLine);
 723
 724     // Use the initial line loop to position children in the cross axis for
 725     // as long as they are relatively positioned with alignment STRETCH or
 726     // FLEX_START. Children that are immediately stacked in the initial loop
 727     // will not be touched again in <Loop D>.
 728     bool isSimpleStackCross = true;
 729     int firstComplexCross = childCount;
 730
 731     css_node_t* firstFlexChild = NULL;
 732     css_node_t* currentFlexChild = NULL;
 733
 734     float mainDim = leadingPaddingAndBorderMain;
 735     float crossDim = 0;
 736
 737     float maxWidth = CSS_UNDEFINED;
 738     float maxHeight = CSS_UNDEFINED;
 739     for (i = startLine; i < childCount; ++i) {
 740       child = node->get_child(node->context, i);
 741       child->line_index = linesCount;
 742
 743       child->next_absolute_child = NULL;
 744       child->next_flex_child = NULL;
 745
 746       css_align_t alignItem = getAlignItem(node, child);
 747
 748       // Pre-fill cross axis dimensions when the child is using stretch before
 749       // we call the recursive layout pass
 750       if (alignItem == CSS_ALIGN_STRETCH &&
 751           child->style.position_type == CSS_POSITION_RELATIVE &&
 752           isCrossDimDefined &&
 753           !isStyleDimDefined(child, crossAxis)) {
 754         child->layout.dimensions[dim[crossAxis]] = fmaxf(
 755           boundAxis(child, crossAxis, node->layout.dimensions[dim[crossAxis]] -
 756             paddingAndBorderAxisCross - getMarginAxis(child, crossAxis)),
 757           // You never want to go smaller than padding
 758           getPaddingAndBorderAxis(child, crossAxis)
 759         );
 760       } else if (child->style.position_type == CSS_POSITION_ABSOLUTE) {
 761         // Store a private linked list of absolutely positioned children
 762         // so that we can efficiently traverse them later.
 763         if (firstAbsoluteChild == NULL) {
 764           firstAbsoluteChild = child;
 765         }
 766         if (currentAbsoluteChild != NULL) {
 767           currentAbsoluteChild->next_absolute_child = child;
 768         }
 769         currentAbsoluteChild = child;
 770
 771         // Pre-fill dimensions when using absolute position and both offsets for the axis are defined (either both
 772         // left and right or top and bottom).
 773         for (ii = 0; ii < 2; ii++) {
 774           axis = (ii != 0) ? CSS_FLEX_DIRECTION_ROW : CSS_FLEX_DIRECTION_COLUMN;
 775           if (isLayoutDimDefined(node, axis) &&
 776               !isStyleDimDefined(child, axis) &&
 777               isPosDefined(child, leading[axis]) &&
 778               isPosDefined(child, trailing[axis])) {
 779             child->layout.dimensions[dim[axis]] = fmaxf(
 780               boundAxis(child, axis, node->layout.dimensions[dim[axis]] -
 781                 getPaddingAndBorderAxis(node, axis) -
 782                 getMarginAxis(child, axis) -
 783                 getPosition(child, leading[axis]) -
 784                 getPosition(child, trailing[axis])),
 785               // You never want to go smaller than padding
 786               getPaddingAndBorderAxis(child, axis)
 787             );
 788           }
 789         }
 790       }
 791
 792       float nextContentDim = 0;
 793
 794       // It only makes sense to consider a child flexible if we have a computed
 795       // dimension for the node->
 796       if (isMainDimDefined && isFlex(child)) {
 797         flexibleChildrenCount++;
 798         totalFlexible += child->style.flex;
 799
 800         // Store a private linked list of flexible children so that we can
 801         // efficiently traverse them later.
 802         if (firstFlexChild == NULL) {
 803           firstFlexChild = child;
 804         }
 805         if (currentFlexChild != NULL) {
 806           currentFlexChild->next_flex_child = child;
 807         }
 808         currentFlexChild = child;
 809
 810         // Even if we don't know its exact size yet, we already know the padding,
 811         // border and margin. We'll use this partial information, which represents
 812         // the smallest possible size for the child, to compute the remaining
 813         // available space.
 814         nextContentDim = getPaddingAndBorderAxis(child, mainAxis) +
 815           getMarginAxis(child, mainAxis);
 816
 817       } else {
 818         maxWidth = CSS_UNDEFINED;
 819         maxHeight = CSS_UNDEFINED;
 820
 821         if (!isMainRowDirection) {
 822           if (isLayoutDimDefined(node, resolvedRowAxis)) {
 823             maxWidth = node->layout.dimensions[dim[resolvedRowAxis]] -
 824               paddingAndBorderAxisResolvedRow;
 825           } else {
 826             maxWidth = parentMaxWidth -
 827               getMarginAxis(node, resolvedRowAxis) -
 828               paddingAndBorderAxisResolvedRow;
 829           }
 830         } else {
 831           if (isLayoutDimDefined(node, CSS_FLEX_DIRECTION_COLUMN)) {
 832             maxHeight = node->layout.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] -
 833                 paddingAndBorderAxisColumn;
 834           } else {
 835             maxHeight = parentMaxHeight -
 836               getMarginAxis(node, CSS_FLEX_DIRECTION_COLUMN) -
 837               paddingAndBorderAxisColumn;
 838           }
 839         }
 840
 841         // This is the main recursive call. We layout non flexible children.
 842         if (alreadyComputedNextLayout == 0) {
 843           layoutNode(child, maxWidth, maxHeight, direction);
 844         }
 845
 846         // Absolute positioned elements do not take part of the layout, so we
 847         // don't use them to compute mainContentDim
 848         if (child->style.position_type == CSS_POSITION_RELATIVE) {
 849           nonFlexibleChildrenCount++;
 850           // At this point we know the final size and margin of the element.
 851           nextContentDim = getDimWithMargin(child, mainAxis);
 852         }
 853       }
 854
 855       // The element we are about to add would make us go to the next line
 856       if (isNodeFlexWrap &&
 857           isMainDimDefined &&
 858           mainContentDim + nextContentDim > definedMainDim &&
 859           // If there's only one element, then it's bigger than the content
 860           // and needs its own line
 861           i != startLine) {
 862         nonFlexibleChildrenCount--;
 863         alreadyComputedNextLayout = 1;
 864         break;
 865       }
 866
 867       // Disable simple stacking in the main axis for the current line as
 868       // we found a non-trivial child-> The remaining children will be laid out
 869       // in <Loop C>.
 870       if (isSimpleStackMain &&
 871           (child->style.position_type != CSS_POSITION_RELATIVE || isFlex(child))) {
 872         isSimpleStackMain = false;
 873         firstComplexMain = i;
 874       }
 875
 876       // Disable simple stacking in the cross axis for the current line as
 877       // we found a non-trivial child-> The remaining children will be laid out
 878       // in <Loop D>.
 879       if (isSimpleStackCross &&
 880           (child->style.position_type != CSS_POSITION_RELATIVE ||
 881               (alignItem != CSS_ALIGN_STRETCH && alignItem != CSS_ALIGN_FLEX_START) ||
 882               (alignItem == CSS_ALIGN_STRETCH && !isCrossDimDefined))) {
 883         isSimpleStackCross = false;
 884         firstComplexCross = i;
 885       }
 886
 887       if (isSimpleStackMain) {
 888         child->layout.position[pos[mainAxis]] += mainDim;
 889         if (isMainDimDefined) {
 890           setTrailingPosition(node, child, mainAxis);
 891         }
 892
 893         mainDim += getDimWithMargin(child, mainAxis);
 894         crossDim = fmaxf(crossDim, boundAxis(child, crossAxis, getDimWithMargin(child, crossAxis)));
 895       }
 896
 897       if (isSimpleStackCross) {
 898         child->layout.position[pos[crossAxis]] += linesCrossDim + leadingPaddingAndBorderCross;
 899         if (isCrossDimDefined) {
 900           setTrailingPosition(node, child, crossAxis);
 901         }
 902       }
 903
 904       alreadyComputedNextLayout = 0;
 905       mainContentDim += nextContentDim;
 906       endLine = i + 1;
 907     }
 908
 909     // <Loop B> Layout flexible children and allocate empty space
 910
 911     // In order to position the elements in the main axis, we have two
 912     // controls. The space between the beginning and the first element
 913     // and the space between each two elements.
 914     float leadingMainDim = 0;
 915     float betweenMainDim = 0;
 916
 917     // The remaining available space that needs to be allocated
 918     float remainingMainDim = 0;
 919     if (isMainDimDefined) {
 920       remainingMainDim = definedMainDim - mainContentDim;
 921     } else {
 922       remainingMainDim = fmaxf(mainContentDim, 0) - mainContentDim;
 923     }
 924
 925     // If there are flexible children in the mix, they are going to fill the
 926     // remaining space
 927     if (flexibleChildrenCount != 0) {
 928       float flexibleMainDim = remainingMainDim / totalFlexible;
 929       float baseMainDim;
 930       float boundMainDim;
 931
 932       // If the flex share of remaining space doesn't meet min/max bounds,
 933       // remove this child from flex calculations.
 934       currentFlexChild = firstFlexChild;
 935       while (currentFlexChild != NULL) {
 936         baseMainDim = flexibleMainDim * currentFlexChild->style.flex +
 937             getPaddingAndBorderAxis(currentFlexChild, mainAxis);
 938         boundMainDim = boundAxis(currentFlexChild, mainAxis, baseMainDim);
 939
 940         if (baseMainDim != boundMainDim) {
 941           remainingMainDim -= boundMainDim;
 942           totalFlexible -= currentFlexChild->style.flex;
 943         }
 944
 945         currentFlexChild = currentFlexChild->next_flex_child;
 946       }
 947       flexibleMainDim = remainingMainDim / totalFlexible;
 948
 949       // The non flexible children can overflow the container, in this case
 950       // we should just assume that there is no space available.
 951       if (flexibleMainDim < 0) {
 952         flexibleMainDim = 0;
 953       }
 954
 955       currentFlexChild = firstFlexChild;
 956       while (currentFlexChild != NULL) {
 957         // At this point we know the final size of the element in the main
 958         // dimension
 959         currentFlexChild->layout.dimensions[dim[mainAxis]] = boundAxis(currentFlexChild, mainAxis,
 960           flexibleMainDim * currentFlexChild->style.flex +
 961               getPaddingAndBorderAxis(currentFlexChild, mainAxis)
 962         );
 963
 964         maxWidth = CSS_UNDEFINED;
 965         if (isLayoutDimDefined(node, resolvedRowAxis)) {
 966           maxWidth = node->layout.dimensions[dim[resolvedRowAxis]] -
 967             paddingAndBorderAxisResolvedRow;
 968         } else if (!isMainRowDirection) {
 969           maxWidth = parentMaxWidth -
 970             getMarginAxis(node, resolvedRowAxis) -
 971             paddingAndBorderAxisResolvedRow;
 972         }
 973         maxHeight = CSS_UNDEFINED;
 974         if (isLayoutDimDefined(node, CSS_FLEX_DIRECTION_COLUMN)) {
 975           maxHeight = node->layout.dimensions[dim[CSS_FLEX_DIRECTION_COLUMN]] -
 976             paddingAndBorderAxisColumn;
 977         } else if (isMainRowDirection) {
 978           maxHeight = parentMaxHeight -
 979             getMarginAxis(node, CSS_FLEX_DIRECTION_COLUMN) -
 980             paddingAndBorderAxisColumn;
 981         }
 982
 983         // And we recursively call the layout algorithm for this child
 984         layoutNode(currentFlexChild, maxWidth, maxHeight, direction);
 985
 986         child = currentFlexChild;
 987         currentFlexChild = currentFlexChild->next_flex_child;
 988         child->next_flex_child = NULL;
 989       }
 990
 991     // We use justifyContent to figure out how to allocate the remaining
 992     // space available
 993     } else if (justifyContent != CSS_JUSTIFY_FLEX_START) {
 994       if (justifyContent == CSS_JUSTIFY_CENTER) {
 995         leadingMainDim = remainingMainDim / 2;
 996       } else if (justifyContent == CSS_JUSTIFY_FLEX_END) {
 997         leadingMainDim = remainingMainDim;
 998       } else if (justifyContent == CSS_JUSTIFY_SPACE_BETWEEN) {
 999         remainingMainDim = fmaxf(remainingMainDim, 0);
1000         if (flexibleChildrenCount + nonFlexibleChildrenCount - 1 != 0) {
1001           betweenMainDim = remainingMainDim /
1002             (flexibleChildrenCount + nonFlexibleChildrenCount - 1);
1003         } else {
1004           betweenMainDim = 0;
1005         }
1006       } else if (justifyContent == CSS_JUSTIFY_SPACE_AROUND) {
1007         // Space on the edges is half of the space between elements
1008         betweenMainDim = remainingMainDim /
1009           (flexibleChildrenCount + nonFlexibleChildrenCount);
1010         leadingMainDim = betweenMainDim / 2;
1011       }
1012     }
1013
1014     // <Loop C> Position elements in the main axis and compute dimensions
1015
1016     // At this point, all the children have their dimensions set. We need to
1017     // find their position. In order to do that, we accumulate data in
1018     // variables that are also useful to compute the total dimensions of the
1019     // container!
1020     mainDim += leadingMainDim;
1021
1022     for (i = firstComplexMain; i < endLine; ++i) {
1023       child = node->get_child(node->context, i);
1024
1025       if (child->style.position_type == CSS_POSITION_ABSOLUTE &&
1026           isPosDefined(child, leading[mainAxis])) {
1027         // In case the child is position absolute and has left/top being
1028         // defined, we override the position to whatever the user said
1029         // (and margin/border).
1030         child->layout.position[pos[mainAxis]] = getPosition(child, leading[mainAxis]) +
1031           getLeadingBorder(node, mainAxis) +
1032           getLeadingMargin(child, mainAxis);
1033       } else {
1034         // If the child is position absolute (without top/left) or relative,
1035         // we put it at the current accumulated offset.
1036         child->layout.position[pos[mainAxis]] += mainDim;
1037
1038         // Define the trailing position accordingly.
1039         if (isMainDimDefined) {
1040           setTrailingPosition(node, child, mainAxis);
1041         }
1042
1043         // Now that we placed the element, we need to update the variables
1044         // We only need to do that for relative elements. Absolute elements
1045         // do not take part in that phase.
1046         if (child->style.position_type == CSS_POSITION_RELATIVE) {
1047           // The main dimension is the sum of all the elements dimension plus
1048           // the spacing.
1049           mainDim += betweenMainDim + getDimWithMargin(child, mainAxis);
1050           // The cross dimension is the max of the elements dimension since there
1051           // can only be one element in that cross dimension.
1052           crossDim = fmaxf(crossDim, boundAxis(child, crossAxis, getDimWithMargin(child, crossAxis)));
1053         }
1054       }
1055     }
1056
1057     float containerCrossAxis = node->layout.dimensions[dim[crossAxis]];
1058     if (!isCrossDimDefined) {
1059       containerCrossAxis = fmaxf(
1060         // For the cross dim, we add both sides at the end because the value
1061         // is aggregate via a max function. Intermediate negative values
1062         // can mess this computation otherwise
1063         boundAxis(node, crossAxis, crossDim + paddingAndBorderAxisCross),
1064         paddingAndBorderAxisCross
1065       );
1066     }
1067
1068     // <Loop D> Position elements in the cross axis
1069     for (i = firstComplexCross; i < endLine; ++i) {
1070       child = node->get_child(node->context, i);
1071
1072       if (child->style.position_type == CSS_POSITION_ABSOLUTE &&
1073           isPosDefined(child, leading[crossAxis])) {
1074         // In case the child is absolutely positionned and has a
1075         // top/left/bottom/right being set, we override all the previously
1076         // computed positions to set it correctly.
1077         child->layout.position[pos[crossAxis]] = getPosition(child, leading[crossAxis]) +
1078           getLeadingBorder(node, crossAxis) +
1079           getLeadingMargin(child, crossAxis);
1080
1081       } else {
1082         float leadingCrossDim = leadingPaddingAndBorderCross;
1083
1084         // For a relative children, we're either using alignItems (parent) or
1085         // alignSelf (child) in order to determine the position in the cross axis
1086         if (child->style.position_type == CSS_POSITION_RELATIVE) {
1087           /*eslint-disable */
1088           // This variable is intentionally re-defined as the code is transpiled to a block scope language
1089           css_align_t alignItem = getAlignItem(node, child);
1090           /*eslint-enable */
1091           if (alignItem == CSS_ALIGN_STRETCH) {
1092             // You can only stretch if the dimension has not already been defined
1093             // previously.
1094             if (!isStyleDimDefined(child, crossAxis)) {
1095               float dimCrossAxis = child->layout.dimensions[dim[crossAxis]];
1096               child->layout.dimensions[dim[crossAxis]] = fmaxf(
1097                 boundAxis(child, crossAxis, containerCrossAxis -
1098                   paddingAndBorderAxisCross - getMarginAxis(child, crossAxis)),
1099                 // You never want to go smaller than padding
1100                 getPaddingAndBorderAxis(child, crossAxis)
1101               );
1102
1103               // If the size has changed, and this child has children we need to re-layout this child
1104               if (dimCrossAxis != child->layout.dimensions[dim[crossAxis]] && child->children_count > 0) {
1105                 // Reset child margins before re-layout as they are added back in layoutNode and would be doubled
1106                 child->layout.position[leading[mainAxis]] -= getLeadingMargin(child, mainAxis) +
1107                   getRelativePosition(child, mainAxis);
1108                 child->layout.position[trailing[mainAxis]] -= getTrailingMargin(child, mainAxis) +
1109                   getRelativePosition(child, mainAxis);
1110                 child->layout.position[leading[crossAxis]] -= getLeadingMargin(child, crossAxis) +
1111                   getRelativePosition(child, crossAxis);
1112                 child->layout.position[trailing[crossAxis]] -= getTrailingMargin(child, crossAxis) +
1113                   getRelativePosition(child, crossAxis);
1114
1115                 layoutNode(child, maxWidth, maxHeight, direction);
1116               }
1117             }
1118           } else if (alignItem != CSS_ALIGN_FLEX_START) {
1119             // The remaining space between the parent dimensions+padding and child
1120             // dimensions+margin.
1121             float remainingCrossDim = containerCrossAxis -
1122               paddingAndBorderAxisCross - getDimWithMargin(child, crossAxis);
1123
1124             if (alignItem == CSS_ALIGN_CENTER) {
1125               leadingCrossDim += remainingCrossDim / 2;
1126             } else { // CSS_ALIGN_FLEX_END
1127               leadingCrossDim += remainingCrossDim;
1128             }
1129           }
1130         }
1131
1132         // And we apply the position
1133         child->layout.position[pos[crossAxis]] += linesCrossDim + leadingCrossDim;
1134
1135         // Define the trailing position accordingly.
1136         if (isCrossDimDefined) {
1137           setTrailingPosition(node, child, crossAxis);
1138         }
1139       }
1140     }
1141
1142     linesCrossDim += crossDim;
1143     linesMainDim = fmaxf(linesMainDim, mainDim);
1144     linesCount += 1;
1145     startLine = endLine;
1146   }
1147
1148   // <Loop E>
1149   //
1150   // Note(prenaux): More than one line, we need to layout the crossAxis
1151   // according to alignContent.
1152   //
1153   // Note that we could probably remove <Loop D> and handle the one line case
1154   // here too, but for the moment this is safer since it won't interfere with
1155   // previously working code.
1156   //
1157   // See specs:
1158   // http://www.w3.org/TR/2012/CR-css3-flexbox-20120918/#layout-algorithm
1159   // section 9.4
1160   //
1161   if (linesCount > 1 && isCrossDimDefined) {
1162     float nodeCrossAxisInnerSize = node->layout.dimensions[dim[crossAxis]] -
1163         paddingAndBorderAxisCross;
1164     float remainingAlignContentDim = nodeCrossAxisInnerSize - linesCrossDim;
1165
1166     float crossDimLead = 0;
1167     float currentLead = leadingPaddingAndBorderCross;
1168
1169     css_align_t alignContent = node->style.align_content;
1170     if (alignContent == CSS_ALIGN_FLEX_END) {
1171       currentLead += remainingAlignContentDim;
1172     } else if (alignContent == CSS_ALIGN_CENTER) {
1173       currentLead += remainingAlignContentDim / 2;
1174     } else if (alignContent == CSS_ALIGN_STRETCH) {
1175       if (nodeCrossAxisInnerSize > linesCrossDim) {
1176         crossDimLead = (remainingAlignContentDim / linesCount);
1177       }
1178     }
1179
1180     int endIndex = 0;
1181     for (i = 0; i < linesCount; ++i) {
1182       int startIndex = endIndex;
1183
1184       // compute the line's height and find the endIndex
1185       float lineHeight = 0;
1186       for (ii = startIndex; ii < childCount; ++ii) {
1187         child = node->get_child(node->context, ii);
1188         if (child->style.position_type != CSS_POSITION_RELATIVE) {
1189           continue;
1190         }
1191         if (child->line_index != i) {
1192           break;
1193         }
1194         if (isLayoutDimDefined(child, crossAxis)) {
1195           lineHeight = fmaxf(
1196             lineHeight,
1197             child->layout.dimensions[dim[crossAxis]] + getMarginAxis(child, crossAxis)
1198           );
1199         }
1200       }
1201       endIndex = ii;
1202       lineHeight += crossDimLead;
1203
1204       for (ii = startIndex; ii < endIndex; ++ii) {
1205         child = node->get_child(node->context, ii);
1206         if (child->style.position_type != CSS_POSITION_RELATIVE) {
1207           continue;
1208         }
1209
1210         css_align_t alignContentAlignItem = getAlignItem(node, child);
1211         if (alignContentAlignItem == CSS_ALIGN_FLEX_START) {
1212           child->layout.position[pos[crossAxis]] = currentLead + getLeadingMargin(child, crossAxis);
1213         } else if (alignContentAlignItem == CSS_ALIGN_FLEX_END) {
1214           child->layout.position[pos[crossAxis]] = currentLead + lineHeight - getTrailingMargin(child, crossAxis) - child->layout.dimensions[dim[crossAxis]];
1215         } else if (alignContentAlignItem == CSS_ALIGN_CENTER) {
1216           float childHeight = child->layout.dimensions[dim[crossAxis]];
1217           child->layout.position[pos[crossAxis]] = currentLead + (lineHeight - childHeight) / 2;
1218         } else if (alignContentAlignItem == CSS_ALIGN_STRETCH) {
1219           child->layout.position[pos[crossAxis]] = currentLead + getLeadingMargin(child, crossAxis);
1220           // TODO(prenaux): Correctly set the height of items with undefined
1221           //                (auto) crossAxis dimension.
1222         }
1223       }
1224
1225       currentLead += lineHeight;
1226     }
1227   }
1228
1229   bool needsMainTrailingPos = false;
1230   bool needsCrossTrailingPos = false;
1231
1232   // If the user didn't specify a width or height, and it has not been set
1233   // by the container, then we set it via the children.
1234   if (!isMainDimDefined) {
1235     node->layout.dimensions[dim[mainAxis]] = fmaxf(
1236       // We're missing the last padding at this point to get the final
1237       // dimension
1238       boundAxis(node, mainAxis, linesMainDim + getTrailingPaddingAndBorder(node, mainAxis)),
1239       // We can never assign a width smaller than the padding and borders
1240       paddingAndBorderAxisMain
1241     );
1242
1243     if (mainAxis == CSS_FLEX_DIRECTION_ROW_REVERSE ||
1244         mainAxis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
1245       needsMainTrailingPos = true;
1246     }
1247   }
1248
1249   if (!isCrossDimDefined) {
1250     node->layout.dimensions[dim[crossAxis]] = fmaxf(
1251       // For the cross dim, we add both sides at the end because the value
1252       // is aggregate via a max function. Intermediate negative values
1253       // can mess this computation otherwise
1254       boundAxis(node, crossAxis, linesCrossDim + paddingAndBorderAxisCross),
1255       paddingAndBorderAxisCross
1256     );
1257
1258     if (crossAxis == CSS_FLEX_DIRECTION_ROW_REVERSE ||
1259         crossAxis == CSS_FLEX_DIRECTION_COLUMN_REVERSE) {
1260       needsCrossTrailingPos = true;
1261     }
1262   }
1263
1264   // <Loop F> Set trailing position if necessary
1265   if (needsMainTrailingPos || needsCrossTrailingPos) {
1266     for (i = 0; i < childCount; ++i) {
1267       child = node->get_child(node->context, i);
1268
1269       if (needsMainTrailingPos) {
1270         setTrailingPosition(node, child, mainAxis);
1271       }
1272
1273       if (needsCrossTrailingPos) {
1274         setTrailingPosition(node, child, crossAxis);
1275       }
1276     }
1277   }
1278
1279   // <Loop G> Calculate dimensions for absolutely positioned elements
1280   currentAbsoluteChild = firstAbsoluteChild;
1281   while (currentAbsoluteChild != NULL) {
1282     // Pre-fill dimensions when using absolute position and both offsets for
1283     // the axis are defined (either both left and right or top and bottom).
1284     for (ii = 0; ii < 2; ii++) {
1285       axis = (ii != 0) ? CSS_FLEX_DIRECTION_ROW : CSS_FLEX_DIRECTION_COLUMN;
1286
1287       if (isLayoutDimDefined(node, axis) &&
1288           !isStyleDimDefined(currentAbsoluteChild, axis) &&
1289           isPosDefined(currentAbsoluteChild, leading[axis]) &&
1290           isPosDefined(currentAbsoluteChild, trailing[axis])) {
1291         currentAbsoluteChild->layout.dimensions[dim[axis]] = fmaxf(
1292           boundAxis(currentAbsoluteChild, axis, node->layout.dimensions[dim[axis]] -
1293             getBorderAxis(node, axis) -
1294             getMarginAxis(currentAbsoluteChild, axis) -
1295             getPosition(currentAbsoluteChild, leading[axis]) -
1296             getPosition(currentAbsoluteChild, trailing[axis])
1297           ),
1298           // You never want to go smaller than padding
1299           getPaddingAndBorderAxis(currentAbsoluteChild, axis)
1300         );
1301       }
1302
1303       if (isPosDefined(currentAbsoluteChild, trailing[axis]) &&
1304           !isPosDefined(currentAbsoluteChild, leading[axis])) {
1305         currentAbsoluteChild->layout.position[leading[axis]] =
1306           node->layout.dimensions[dim[axis]] -
1307           currentAbsoluteChild->layout.dimensions[dim[axis]] -
1308           getPosition(currentAbsoluteChild, trailing[axis]);
1309       }
1310     }
1311
1312     child = currentAbsoluteChild;
1313     currentAbsoluteChild = currentAbsoluteChild->next_absolute_child;
1314     child->next_absolute_child = NULL;
1315   }
1316   /** END_GENERATED **/
1317 }
1318
1319 void layoutNode(css_node_t *node, float parentMaxWidth, float parentMaxHeight, css_direction_t parentDirection) {
1320   css_layout_t *layout = &node->layout;
1321   css_direction_t direction = node->style.direction;
1322   layout->should_update = true;
1323
1324   bool skipLayout =
1325     !node->is_dirty(node->context) &&
1326     eq(layout->last_requested_dimensions[CSS_WIDTH], layout->dimensions[CSS_WIDTH]) &&
1327     eq(layout->last_requested_dimensions[CSS_HEIGHT], layout->dimensions[CSS_HEIGHT]) &&
1328     eq(layout->last_parent_max_width, parentMaxWidth) &&
1329     eq(layout->last_parent_max_height, parentMaxHeight) &&
1330     eq(layout->last_direction, direction);
1331
1332   if (skipLayout) {
1333     layout->dimensions[CSS_WIDTH] = layout->last_dimensions[CSS_WIDTH];
1334     layout->dimensions[CSS_HEIGHT] = layout->last_dimensions[CSS_HEIGHT];
1335     layout->position[CSS_TOP] = layout->last_position[CSS_TOP];
1336     layout->position[CSS_LEFT] = layout->last_position[CSS_LEFT];
1337   } else {
1338     layout->last_requested_dimensions[CSS_WIDTH] = layout->dimensions[CSS_WIDTH];
1339     layout->last_requested_dimensions[CSS_HEIGHT] = layout->dimensions[CSS_HEIGHT];
1340     layout->last_parent_max_width = parentMaxWidth;
1341     layout->last_parent_max_height = parentMaxHeight;
1342     layout->last_direction = direction;
1343
1344     int i, childCount;
1345     for (i = 0, childCount = node->children_count; i < childCount; i++) {
1346       resetNodeLayout(node->get_child(node->context, i));
1347     }
1348
1349     layoutNodeImpl(node, parentMaxWidth, parentMaxHeight, parentDirection);
1350
1351     layout->last_dimensions[CSS_WIDTH] = layout->dimensions[CSS_WIDTH];
1352     layout->last_dimensions[CSS_HEIGHT] = layout->dimensions[CSS_HEIGHT];
1353     layout->last_position[CSS_TOP] = layout->position[CSS_TOP];
1354     layout->last_position[CSS_LEFT] = layout->position[CSS_LEFT];
1355   }
1356
1357 #if defined(FLEXBOX_LAYOUT_NODE_DEBUG)
1358   printf("Input:    ");
1359   print_css_node(node, (css_print_options_t)(CSS_PRINT_STYLE | CSS_PRINT_CHILDREN));
1360   printf("Output:   ");
1361   print_css_node(node, (css_print_options_t)(CSS_PRINT_LAYOUT | CSS_PRINT_CHILDREN));
1362   printf("\n");
1363 #endif // defined(FLEXBOX_LAYOUT_NODE_DEBUG)
1364 }
1365
1366 void resetNodeLayout(css_node_t *node) {
1367   node->layout.dimensions[CSS_WIDTH] = CSS_UNDEFINED;
1368   node->layout.dimensions[CSS_HEIGHT] = CSS_UNDEFINED;
1369   node->layout.position[CSS_LEFT] = 0;
1370   node->layout.position[CSS_TOP] = 0;
1371 }