update method

@override bool update()

Implementation

@override
bool update() {
  if (offset == 0) {
    return false;
  }

  final mainSize = getItemSize(_mainItem);
  final mainMinSize = getItemMinSize(_mainItem);

  final setMainSize =
      mainSize + offset > mainMinSize ? mainSize + offset : mainMinSize;

  if (offset > 0) {
    double remaining = offset;

    final iterPositive = iterateWideItemPositive().iterator;
    while (iterPositive.moveNext()) {
      final siblingSize = getItemSize(iterPositive.current);
      final siblingMinSize = getItemMinSize(iterPositive.current);
      final enough = siblingSize - siblingMinSize;
      final siblingOffsetToSet = enough > remaining ? remaining : enough;
      setItemSize(iterPositive.current, siblingSize - siblingOffsetToSet);
      remaining -= siblingOffsetToSet;
      if (remaining <= 0) {
        setItemSize(_mainItem, mainSize + offset);
        return true;
      }
    }

    final iterNegative = iterateWideItemNegative().iterator;
    while (iterNegative.moveNext()) {
      final siblingSize = getItemSize(iterNegative.current);
      final siblingMinSize = getItemMinSize(iterNegative.current);
      final enough = siblingSize - siblingMinSize;
      final siblingOffsetToSet = enough > remaining ? remaining : enough;
      setItemSize(iterNegative.current, siblingSize - siblingOffsetToSet);
      remaining -= siblingOffsetToSet;
      if (remaining <= 0) {
        setItemSize(_mainItem, mainSize + offset);
        return true;
      }
    }

    if (offset == remaining) {
      return false;
    }

    setItemSize(_mainItem, mainSize + (offset - remaining));

    return true;
  } else {
    if (isFirstMain || isLastMain) {
      if (setMainSize == mainSize) {
        return false;
      }
      final firstSiblingItem =
          isFirstMain ? getFirstItemPositive() : getFirstItemNegative();
      if (firstSiblingItem == null) {
        return false;
      }
      setItemSize(_mainItem, setMainSize);
      final firstSiblingItemWidth = getItemSize(firstSiblingItem);
      setItemSize(
        firstSiblingItem,
        firstSiblingItemWidth + mainSize - setMainSize,
      );
      return true;
    }

    double remainingNegative = offset.abs() - (mainSize - setMainSize);
    if (remainingNegative > 0) {
      final iterNegative = iterateWideItemNegative().iterator;
      while (iterNegative.moveNext()) {
        final siblingSize = getItemSize(iterNegative.current);
        final siblingMinSize = getItemMinSize(iterNegative.current);
        final enough = siblingSize - siblingMinSize;
        final siblingOffsetToSet =
            enough > remainingNegative ? remainingNegative : enough;
        setItemSize(iterNegative.current, siblingSize - siblingOffsetToSet);
        remainingNegative -= siblingOffsetToSet;
        if (remainingNegative <= 0) {
          break;
        }
      }
    }

    if (mainSize == setMainSize &&
        remainingNegative == offset.abs() - (mainSize - setMainSize)) {
      return false;
    }

    setItemSize(_mainItem, setMainSize);

    final firstPositiveItem = getFirstItemPositive();
    assert(firstPositiveItem != null);
    final firstPositiveItemSize = getItemSize(firstPositiveItem as T);
    setItemSize(
      firstPositiveItem,
      firstPositiveItemSize + offset.abs() - remainingNegative,
    );
  }

  return true;
}