layout method

@override void layout(Context context, BoxConstraints constraints, { bool parentUsesSize = false, })

First widget pass to calculate the children layout and bounding box

Implementation

@override
void layout(Context context, BoxConstraints constraints,
    {bool parentUsesSize = false}) {
  if (children.isEmpty) {
    box = PdfRect.zero;
    return;
  }

  assert(() {
    if (constraints.maxHeight.isInfinite && childAspectRatio.isInfinite) {
      print(
          'Unable to calculate the GridView dimensions. Please set the height constraints or childAspectRatio.');
      return false;
    }
    return true;
  }());

  late double mainAxisExtent;
  late double crossAxisExtent;
  switch (direction) {
    case Axis.vertical:
      mainAxisExtent = constraints.maxHeight - padding.vertical;
      crossAxisExtent = constraints.maxWidth - padding.horizontal;
      break;
    case Axis.horizontal:
      mainAxisExtent = constraints.maxWidth - padding.horizontal;
      crossAxisExtent = constraints.maxHeight - padding.vertical;
      break;
  }

  if (constraints.maxHeight.isInfinite || _mainAxisCount == null) {
    _mainAxisCount =
        ((children.length - _context.firstChild) / crossAxisCount).ceil();

    _context.childCrossAxis = crossAxisExtent / crossAxisCount -
        (crossAxisSpacing * (crossAxisCount - 1) / crossAxisCount);

    _context.childMainAxis = math.min(
        _context.childCrossAxis! * childAspectRatio,
        mainAxisExtent / _mainAxisCount! -
            (mainAxisSpacing * (_mainAxisCount! - 1) / _mainAxisCount!));

    if (_context.childCrossAxis!.isInfinite) {
      throw Exception(
          'Unable to calculate child height as the height constraint is infinite.');
    }
  } else {
    _mainAxisCount = ((mainAxisExtent + mainAxisSpacing) /
            (mainAxisSpacing + _context.childMainAxis!))
        .floor();

    if (_mainAxisCount! < 0) {
      // Not enough space to put one line, try to ask for more space.
      _mainAxisCount = 0;
    }
  }

  final totalMain =
      (_context.childMainAxis! + mainAxisSpacing) * _mainAxisCount! -
          mainAxisSpacing;
  final totalCross =
      (_context.childCrossAxis! + crossAxisSpacing) * crossAxisCount -
          crossAxisSpacing;

  final startX = padding.left;
  const startY = 0.0;
  late double mainAxis;
  late double crossAxis;
  BoxConstraints? innerConstraints;
  switch (direction) {
    case Axis.vertical:
      innerConstraints = BoxConstraints.tightFor(
          width: _context.childCrossAxis, height: _context.childMainAxis);
      crossAxis = startX;
      mainAxis = startY;
      break;
    case Axis.horizontal:
      innerConstraints = BoxConstraints.tightFor(
          width: _context.childMainAxis, height: _context.childCrossAxis);
      mainAxis = startX;
      crossAxis = startY;
      break;
  }

  var c = 0;
  _context.lastChild = _context.firstChild;

  for (final child in children.sublist(
      _context.firstChild,
      math.min(children.length,
          _context.firstChild + crossAxisCount * _mainAxisCount!))) {
    child.layout(context, innerConstraints);
    assert(child.box != null);

    switch (direction) {
      case Axis.vertical:
        child.box = PdfRect.fromPoints(
            PdfPoint(
                (_context.childCrossAxis! - child.box!.width) / 2.0 +
                    crossAxis,
                totalMain +
                    padding.bottom -
                    (_context.childMainAxis! - child.box!.height) / 2.0 -
                    mainAxis -
                    child.box!.height),
            child.box!.size);
        break;
      case Axis.horizontal:
        child.box = PdfRect.fromPoints(
            PdfPoint(
                (_context.childMainAxis! - child.box!.width) / 2.0 + mainAxis,
                totalCross +
                    padding.bottom -
                    (_context.childCrossAxis! - child.box!.height) / 2.0 -
                    crossAxis -
                    child.box!.height),
            child.box!.size);
        break;
    }

    if (++c >= crossAxisCount) {
      mainAxis += _context.childMainAxis! + mainAxisSpacing;
      switch (direction) {
        case Axis.vertical:
          crossAxis = startX;
          break;
        case Axis.horizontal:
          crossAxis = startY;
          break;
      }
      c = 0;

      if (mainAxis > mainAxisExtent) {
        _context.lastChild++;

        break;
      }
    } else {
      crossAxis += _context.childCrossAxis! + crossAxisSpacing;
    }
    _context.lastChild++;
  }

  switch (direction) {
    case Axis.vertical:
      box = constraints.constrainRect(
          width: totalCross + padding.horizontal,
          height: totalMain + padding.vertical);
      break;
    case Axis.horizontal:
      box = constraints.constrainRect(
          width: totalMain + padding.horizontal,
          height: totalCross + padding.vertical);
      break;
  }
}