calculate static method

Implementation

static int calculate({
  required BoxConstraints constraints,
  required int length,
}) {
  // Number of columns.
  int mColumns = 0;

  // Minimal diagonal of a square.
  double min = double.infinity;

  // To find the [mColumns], iterate through every possible number of
  // columns and pick the arrangement with [min]imal diagonal.
  for (int columns = 1; columns <= length; ++columns) {
    int rows = (length / columns).ceil();

    // Current diagonal of a single square.
    double diagonal =
        (pow(constraints.maxWidth / columns, 2) +
                pow(constraints.maxHeight / rows, 2))
            .toDouble();

    // If there's any [children] left outside, then their diagonal will
    // always be bigger, so we need to recalculate.
    int outside = length % columns;
    if (outside != 0) {
      // Diagonal of an outside [children] is calculated with some
      // coefficient to force the algorithm to pick non-standard
      // arrangement.
      double coef = 1;

      // Coefficient is hard-coded for some cases in order to [FitView] to
      // look better.
      if (length == 3) {
        coef = constraints.maxWidth > constraints.maxHeight ? 0.5 : 0.87;
      } else if (length == 5) {
        if (constraints.maxWidth > constraints.maxHeight) {
          coef = 0.8;
        } else {
          coef = outside == 1 ? 0.8 : 1.5;
        }
      } else if (length == 10) {
        if (constraints.maxWidth > constraints.maxHeight) {
          coef = outside == 2 ? 0.65 : 0.8;
        } else {
          coef = 0.8;
        }
      } else if (length == 9) {
        if (constraints.maxWidth > constraints.maxHeight) {
          coef = 0.9;
        } else {
          coef = 0.5;
        }
      } else if (length == 8) {
        if (constraints.maxWidth > constraints.maxHeight) {
          coef = outside == 2 ? 0.59 : 0.8;
        } else {
          coef = 0.8;
        }
      } else if (length == 7) {
        if (constraints.maxWidth > constraints.maxHeight) {
          coef =
              constraints.maxWidth / constraints.maxHeight >= 3 ? 0.7 : 0.4;
        } else {
          coef = 0.4;
        }
      } else if (length == 6) {
        if (constraints.maxWidth > constraints.maxHeight) {
          coef =
              (constraints.maxWidth / constraints.maxHeight > 3) ? 0.57 : 0.7;
        } else {
          coef = 0.7;
        }
      } else {
        if (constraints.maxWidth > constraints.maxHeight) {
          coef = outside == 2 ? 0.59 : 0.77;
        } else {
          coef = 0.6;
        }
      }

      diagonal =
          (pow(constraints.maxWidth / outside * coef, 2) +
                  pow(constraints.maxHeight / rows, 2))
              .toDouble();
    }
    // Tweak of a standard arrangement.
    else if (length == 4) {
      mColumns =
          constraints.maxWidth / constraints.maxHeight < 0.56 ? 1 : mColumns;
    }

    if (diagonal < min && min - diagonal > 1) {
      mColumns = columns;
      min = diagonal;
    }
  }

  return mColumns;
}