public void setChildParentData(RenderObject child, SliverConstraints constraints, SliverGeometry geometry)
{
var childParentData = (SliverPhysicalParentData)child.parentData;
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(constraints.axisDirection,
constraints.growthDirection))
{
case AxisDirection.up:
childParentData.paintOffset = new Offset(0.0f,
-(geometry.scrollExtent - (geometry.paintExtent + constraints.scrollOffset)));
break;
case AxisDirection.right:
childParentData.paintOffset = new Offset(-constraints.scrollOffset, 0.0f);
break;
case AxisDirection.down:
childParentData.paintOffset = new Offset(0.0f, -constraints.scrollOffset);
break;
case AxisDirection.left:
childParentData.paintOffset =
new Offset(-(geometry.scrollExtent - (geometry.paintExtent + constraints.scrollOffset)),
0.0f);
break;
}
}
public override void paint(PaintingContext context, Offset offset)
{
if (this.child != null && this.geometry.visible)
{
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(this.constraints.axisDirection,
this.constraints.growthDirection))
{
case AxisDirection.up:
offset += new Offset(0.0f,
this.geometry.paintExtent - this.childMainAxisPosition(this.child) - this.childExtent);
break;
case AxisDirection.down:
offset += new Offset(0.0f, this.childMainAxisPosition(this.child));
break;
case AxisDirection.left:
offset += new Offset(
this.geometry.paintExtent - this.childMainAxisPosition(this.child) - this.childExtent,
0.0f);
break;
case AxisDirection.right:
offset += new Offset(this.childMainAxisPosition(this.child), 0.0f);
break;
}
context.paintChild(this.child, offset);
}
}
public override float?childCrossAxisPosition(RenderObject child)
{
child = (RenderSliver)child;
D.assert(child != null);
D.assert(child == this.child);
D.assert(constraints != null);
D.assert(resolvedPadding != null);
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection))
{
case AxisDirection.up:
case AxisDirection.down:
return(resolvedPadding.left);
case AxisDirection.left:
case AxisDirection.right:
return(resolvedPadding.top);
}
return(null);
}
public override float childCrossAxisPosition(RenderObject child)
{
D.assert(child != null);
D.assert(child == this.child);
D.assert(this.constraints != null);
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(
this.constraints.axisDirection, this.constraints.growthDirection))
{
case AxisDirection.up:
case AxisDirection.down:
return(this._padding.left);
case AxisDirection.left:
case AxisDirection.right:
return(this._padding.top);
}
return(0.0f);
}
internal Size getAbsoluteSizeRelativeToOrigin()
{
D.assert(geometry != null);
D.assert(!debugNeedsLayout);
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(
constraints.axisDirection, constraints.growthDirection))
{
case AxisDirection.up:
return(new Size(constraints.crossAxisExtent, -geometry.paintExtent));
case AxisDirection.right:
return(new Size(geometry.paintExtent, constraints.crossAxisExtent));
case AxisDirection.down:
return(new Size(constraints.crossAxisExtent, geometry.paintExtent));
case AxisDirection.left:
return(new Size(-geometry.paintExtent, constraints.crossAxisExtent));
}
return(null);
}
public override void paint(PaintingContext context, Offset offset)
{
if (this.firstChild == null)
{
return;
}
Offset mainAxisUnit = null, crossAxisUnit = null, originOffset = null;
bool addExtent = false;
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(this.constraints.axisDirection,
this.constraints.growthDirection))
{
case AxisDirection.up:
mainAxisUnit = new Offset(0.0f, -1.0f);
crossAxisUnit = new Offset(1.0f, 0.0f);
originOffset = offset + new Offset(0.0f, this.geometry.paintExtent);
addExtent = true;
break;
case AxisDirection.right:
mainAxisUnit = new Offset(1.0f, 0.0f);
crossAxisUnit = new Offset(0.0f, 1.0f);
originOffset = offset;
addExtent = false;
break;
case AxisDirection.down:
mainAxisUnit = new Offset(0.0f, 1.0f);
crossAxisUnit = new Offset(1.0f, 0.0f);
originOffset = offset;
addExtent = false;
break;
case AxisDirection.left:
mainAxisUnit = new Offset(-1.0f, 0.0f);
crossAxisUnit = new Offset(0.0f, 1.0f);
originOffset = offset + new Offset(this.geometry.paintExtent, 0.0f);
addExtent = true;
break;
}
RenderBox child = this.firstChild;
while (child != null)
{
float mainAxisDelta = this.childMainAxisPosition(child);
float crossAxisDelta = this.childCrossAxisPosition(child);
Offset childOffset = new Offset(
originOffset.dx + mainAxisUnit.dx * mainAxisDelta + crossAxisUnit.dx * crossAxisDelta,
originOffset.dy + mainAxisUnit.dy * mainAxisDelta + crossAxisUnit.dy * crossAxisDelta
);
if (addExtent)
{
childOffset += mainAxisUnit * this.paintExtentOf(child);
}
if (mainAxisDelta < this.constraints.remainingPaintExtent &&
mainAxisDelta + this.paintExtentOf(child) > 0)
{
context.paintChild(child, childOffset);
}
child = this.childAfter(child);
}
}
protected override void performLayout()
{
float beforePadding = this.beforePadding;
float afterPadding = this.afterPadding;
float mainAxisPadding = this.mainAxisPadding;
float crossAxisPadding = this.crossAxisPadding;
if (this.child == null)
{
this.geometry = new SliverGeometry(
scrollExtent: mainAxisPadding,
paintExtent: Mathf.Min(mainAxisPadding, this.constraints.remainingPaintExtent),
maxPaintExtent: mainAxisPadding
);
return;
}
this.child.layout(
this.constraints.copyWith(
scrollOffset: Mathf.Max(0.0f, this.constraints.scrollOffset - beforePadding),
cacheOrigin: Mathf.Min(0.0f, this.constraints.cacheOrigin + beforePadding),
overlap: 0.0f,
remainingPaintExtent: this.constraints.remainingPaintExtent -
this.calculatePaintOffset(this.constraints, from: 0.0f, to: beforePadding),
remainingCacheExtent: this.constraints.remainingCacheExtent -
this.calculateCacheOffset(this.constraints, from: 0.0f, to: beforePadding),
crossAxisExtent: Mathf.Max(0.0f, this.constraints.crossAxisExtent - crossAxisPadding)
),
parentUsesSize: true
);
SliverGeometry childLayoutGeometry = this.child.geometry;
if (childLayoutGeometry.scrollOffsetCorrection != null)
{
this.geometry = new SliverGeometry(
scrollOffsetCorrection: childLayoutGeometry.scrollOffsetCorrection
);
return;
}
float beforePaddingPaintExtent = this.calculatePaintOffset(
this.constraints,
from: 0.0f,
to: beforePadding
);
float afterPaddingPaintExtent = this.calculatePaintOffset(
this.constraints,
from: beforePadding + childLayoutGeometry.scrollExtent,
to: mainAxisPadding + childLayoutGeometry.scrollExtent
);
float mainAxisPaddingPaintExtent = beforePaddingPaintExtent + afterPaddingPaintExtent;
float beforePaddingCacheExtent = this.calculateCacheOffset(
this.constraints,
from: 0.0f,
to: beforePadding
);
float afterPaddingCacheExtent = this.calculateCacheOffset(
this.constraints,
from: beforePadding + childLayoutGeometry.scrollExtent,
to: mainAxisPadding + childLayoutGeometry.scrollExtent
);
float mainAxisPaddingCacheExtent = afterPaddingCacheExtent + beforePaddingCacheExtent;
float paintExtent = Mathf.Min(
beforePaddingPaintExtent + Mathf.Max(childLayoutGeometry.paintExtent,
childLayoutGeometry.layoutExtent + afterPaddingPaintExtent),
this.constraints.remainingPaintExtent
);
this.geometry = new SliverGeometry(
scrollExtent: mainAxisPadding + childLayoutGeometry.scrollExtent,
paintExtent: paintExtent,
layoutExtent: Mathf.Min(mainAxisPaddingPaintExtent + childLayoutGeometry.layoutExtent,
paintExtent),
cacheExtent: Mathf.Min(mainAxisPaddingCacheExtent + childLayoutGeometry.cacheExtent,
this.constraints.remainingCacheExtent),
maxPaintExtent: mainAxisPadding + childLayoutGeometry.maxPaintExtent,
hitTestExtent: Mathf.Max(
mainAxisPaddingPaintExtent + childLayoutGeometry.paintExtent,
beforePaddingPaintExtent + childLayoutGeometry.hitTestExtent
),
hasVisualOverflow: childLayoutGeometry.hasVisualOverflow
);
var childParentData = (SliverPhysicalParentData)this.child.parentData;
switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(this.constraints.axisDirection,
this.constraints.growthDirection))
{
case AxisDirection.up:
childParentData.paintOffset = new Offset(this._padding.left,
this.calculatePaintOffset(this.constraints,
from: this._padding.bottom + childLayoutGeometry.scrollExtent,
to: this._padding.bottom + childLayoutGeometry.scrollExtent + this._padding.top));
break;
case AxisDirection.right:
childParentData.paintOffset =
new Offset(this.calculatePaintOffset(this.constraints, from: 0.0f, to: this._padding.left),
this._padding.top);
break;
case AxisDirection.down:
childParentData.paintOffset = new Offset(this._padding.left,
this.calculatePaintOffset(this.constraints, from: 0.0f, to: this._padding.top));
break;
case AxisDirection.left:
childParentData.paintOffset = new Offset(
this.calculatePaintOffset(this.constraints,
from: this._padding.right + childLayoutGeometry.scrollExtent,
to: this._padding.right + childLayoutGeometry.scrollExtent + this._padding.left),
this._padding.top);
break;
}
D.assert(childParentData.paintOffset != null);
D.assert(beforePadding == this.beforePadding);
D.assert(afterPadding == this.afterPadding);
D.assert(mainAxisPadding == this.mainAxisPadding);
D.assert(crossAxisPadding == this.crossAxisPadding);
}
