void _showCaretOnScreen() { if (this._showCaretOnScreenScheduled) { return; } this._showCaretOnScreenScheduled = true; SchedulerBinding.instance.addPostFrameCallback(_ => { this._showCaretOnScreenScheduled = false; if (this._currentCaretRect == null || !this._scrollController.hasClients) { return; } float scrollOffsetForCaret = this._getScrollOffsetForCaret(this._currentCaretRect); this._scrollController.animateTo(scrollOffsetForCaret, duration: _caretAnimationDuration, curve: _caretAnimationCurve); Rect newCaretRect = this._getCaretRectAtScrollOffset(this._currentCaretRect, scrollOffsetForCaret); // Enlarge newCaretRect by scrollPadding to ensure that caret is not positioned directly at the edge after scrolling. Rect inflatedRect = Rect.fromLTRB( newCaretRect.left - this.widget.scrollPadding.left, newCaretRect.top - this.widget.scrollPadding.top, newCaretRect.right + this.widget.scrollPadding.right, newCaretRect.bottom + this.widget.scrollPadding.bottom ); this._editableKey.currentContext.findRenderObject().showOnScreen( rect: inflatedRect, duration: _caretAnimationDuration, curve: _caretAnimationCurve ); }); }
public Rect getRowBox(int row) { D.assert(row >= 0); D.assert(row < rows); D.assert(!debugNeedsLayout); return(Rect.fromLTRB(0.0f, _rowTops[row], size.width, _rowTops[row + 1])); }
Rect _adjustRect(Rect rect) { if (circleness == 0.0 || rect.width == rect.height) { return(rect); } if (rect.width < rect.height) { float delta = circleness * (rect.height - rect.width) / 2.0f; return(Rect.fromLTRB( rect.left, rect.top + delta, rect.right, rect.bottom - delta )); } else { float delta = circleness * (rect.width - rect.height) / 2.0f; return(Rect.fromLTRB( rect.left + delta, rect.top, rect.right - delta, rect.bottom )); } }
Rect getRowBox(int row) { D.assert(row >= 0); D.assert(row < this.rows); return(Rect.fromLTRB(0.0f, this._rowTops[row], this.size.width, this._rowTops[row + 1])); }
public override void paint(PaintingContext context, Offset offset) { Canvas canvas = context.canvas; float currentValue = _state.position.value; float currentReactionValue = _state._reaction.value; float visualPosition = 0.0f; switch (textDirection) { case TextDirection.rtl: visualPosition = 1.0f - currentValue; break; case TextDirection.ltr: visualPosition = currentValue; break; } Paint paint = new Paint() { color = Color.lerp(trackColor, activeColor, currentValue) }; Rect trackRect = Rect.fromLTWH( offset.dx + (size.width - CupertinoSwitchUtils._kTrackWidth) / 2.0f, offset.dy + (size.height - CupertinoSwitchUtils._kTrackHeight) / 2.0f, CupertinoSwitchUtils._kTrackWidth, CupertinoSwitchUtils._kTrackHeight ); RRect trackRRect = RRect.fromRectAndRadius(trackRect, Radius.circular(CupertinoSwitchUtils._kTrackRadius)); canvas.drawRRect(trackRRect, paint); float currentThumbExtension = CupertinoThumbPainter.extension * currentReactionValue; float thumbLeft = MathUtils.lerpNullableFloat( trackRect.left + CupertinoSwitchUtils._kTrackInnerStart - CupertinoThumbPainter.radius, trackRect.left + CupertinoSwitchUtils._kTrackInnerEnd - CupertinoThumbPainter.radius - currentThumbExtension, visualPosition ); float thumbRight = MathUtils.lerpNullableFloat( trackRect.left + CupertinoSwitchUtils._kTrackInnerStart + CupertinoThumbPainter.radius + currentThumbExtension, trackRect.left + CupertinoSwitchUtils._kTrackInnerEnd + CupertinoThumbPainter.radius, visualPosition ); float thumbCenterY = offset.dy + size.height / 2.0f; Rect thumbBounds = Rect.fromLTRB( thumbLeft, thumbCenterY - CupertinoThumbPainter.radius, thumbRight, thumbCenterY + CupertinoThumbPainter.radius ); context.pushClipRRect(needsCompositing, Offset.zero, thumbBounds, trackRRect, (PaintingContext innerContext, Offset offset1) => { CupertinoThumbPainter.switchThumb().paint(innerContext.canvas, thumbBounds); }); }
public Rect toRect(Rect container) { return(Rect.fromLTRB( this.left + container.left, this.top + container.top, container.right - this.right, container.bottom - this.bottom)); }
public Rect toSize(Size container) { return(Rect.fromLTRB( left, top, container.width - right, container.height - bottom)); }
public Rect toSize(Size container) { return(Rect.fromLTRB( this.left, this.top, container.width - this.right, container.height - this.bottom)); }
public static Rect fromCenter(Offset center, float width, float height) { return(Rect.fromLTRB( center.dx - width / 2, center.dy - height / 2, center.dx + width / 2, center.dy + height / 2 )); }
public GlyphInfo(CharacterInfo info) { this.rect = Rect.fromLTRB(info.minX, -info.maxY, info.maxX, -info.minY); this.advance = info.advance; this.glyphHeight = info.glyphHeight; this.uvTopLeft = info.uvTopLeft; this.uvTopRight = info.uvTopRight; this.uvBottomLeft = info.uvBottomLeft; this.uvBottomRight = info.uvBottomRight; }
public override void paint( PaintingContext context, Offset offset, RenderBox parentBox = null, SliderThemeData sliderTheme = null, Animation <float> enableAnimation = null, Offset thumbCenter = null, bool?isEnabled = null, bool?isDiscrete = null) { if (sliderTheme.trackHeight == 0) { return; } ColorTween activeTrackColorTween = new ColorTween(begin: sliderTheme.disabledActiveTrackColor, end: sliderTheme.activeTrackColor); ColorTween inactiveTrackColorTween = new ColorTween(begin: sliderTheme.disabledInactiveTrackColor, end: sliderTheme.inactiveTrackColor); Paint activePaint = new Paint { color = activeTrackColorTween.evaluate(enableAnimation) }; Paint inactivePaint = new Paint { color = inactiveTrackColorTween.evaluate(enableAnimation) }; Paint leftTrackPaint = activePaint; Paint rightTrackPaint = inactivePaint; float horizontalAdjustment = 0.0f; if (!isEnabled.Value) { float disabledThumbRadius = sliderTheme.thumbShape.getPreferredSize(false, isDiscrete).width / 2.0f; float gap = this.disabledThumbGapWidth * (1.0f - enableAnimation.value); horizontalAdjustment = disabledThumbRadius + gap; } Rect trackRect = this.getPreferredRect( parentBox: parentBox, offset: offset, sliderTheme: sliderTheme, isEnabled: isEnabled, isDiscrete: isDiscrete ); Rect leftTrackSegment = Rect.fromLTRB(trackRect.left, trackRect.top, thumbCenter.dx - horizontalAdjustment, trackRect.bottom); context.canvas.drawRect(leftTrackSegment, leftTrackPaint); Rect rightTrackSegment = Rect.fromLTRB(thumbCenter.dx + horizontalAdjustment, trackRect.top, trackRect.right, trackRect.bottom); context.canvas.drawRect(rightTrackSegment, rightTrackPaint); }
void paintBackground(Canvas canvas, PaintRecord record, Offset baseOffset) { if (record.style.background == null) { return; } var metrics = record.metrics; Rect rect = Rect.fromLTRB(0, metrics.ascent, record.runWidth, metrics.descent); rect = rect.shift(record.shiftedOffset(baseOffset)); canvas.drawRect(rect, record.style.background); }
Rect _getRectFromUpstream(int offset, Rect caretPrototype) { string flattenedText = _text.toPlainText(includePlaceholders: false); var prevCodeUnit = _text.codeUnitAt(Mathf.Max(0, offset - 1)); if (prevCodeUnit == null) { return(null); } bool needsSearch = _isUtf16Surrogate(prevCodeUnit.Value) || _text.codeUnitAt(offset) == _zwjUtf16 || _isUnicodeDirectionality(prevCodeUnit); int graphemeClusterLength = needsSearch ? 2 : 1; List <TextBox> boxes = null; while ((boxes == null || boxes.isEmpty()) && flattenedText != null) { int prevRuneOffset = offset - graphemeClusterLength; boxes = _paragraph.getBoxesForRange(prevRuneOffset, offset, boxHeightStyle: BoxHeightStyle.strut); if (boxes.isEmpty()) { if (!needsSearch) { break; } if (prevRuneOffset < -flattenedText.Length) { break; } graphemeClusterLength *= 2; continue; } TextBox box = boxes[0]; const int NEWLINE_CODE_UNIT = 10; if (prevCodeUnit == NEWLINE_CODE_UNIT) { return(Rect.fromLTRB(_emptyOffset.dx, box.bottom, _emptyOffset.dx, box.bottom + box.bottom - box.top)); } float caretEnd = box.end; float dx = box.direction == TextDirection.rtl ? caretEnd - caretPrototype.width : caretEnd; return(Rect.fromLTRB(Mathf.Min(dx, _paragraph.width()), box.top, Mathf.Min(dx, _paragraph.width()), box.bottom)); } return(null); }
public static Rect transformRect(Matrix4x4 transform, Rect rect) { Offset point1 = transformPoint(transform, rect.topLeft); Offset point2 = transformPoint(transform, rect.topRight); Offset point3 = transformPoint(transform, rect.bottomLeft); Offset point4 = transformPoint(transform, rect.bottomRight); return(Rect.fromLTRB( _min4(point1.dx, point2.dx, point3.dx, point4.dx), _min4(point1.dy, point2.dy, point3.dy, point4.dy), _max4(point1.dx, point2.dx, point3.dx, point4.dx), _max4(point1.dy, point2.dy, point3.dy, point4.dy) )); }
internal static Rect _safeTransformRect(Matrix4 transform, Rect rect) { float[] storage = transform.storage; bool isAffine = storage[3] == 0.0 && storage[7] == 0.0 && storage[15] == 1.0; _minMax = _minMax ?? new float[4]; _accumulate(storage, rect.left, rect.top, true, isAffine); _accumulate(storage, rect.right, rect.top, false, isAffine); _accumulate(storage, rect.left, rect.bottom, false, isAffine); _accumulate(storage, rect.right, rect.bottom, false, isAffine); return(Rect.fromLTRB(_minMax[0], _minMax[1], _minMax[2], _minMax[3])); }
public void addPerformanceOverlay(int enabledOptions, Rect bounds) { if (this._currentLayer == null) { return; } var layer = new PerformanceOverlayLayer(enabledOptions); layer.paintBounds = Rect.fromLTRB( bounds.left, bounds.top, bounds.right, bounds.bottom ); this._currentLayer.add(layer); }
public void doLayout(float offset, string text, int start, int count, TextStyle style) { this._text = text; this._advances.Clear(); this._positions.Clear(); this._count = count; var font = FontManager.instance.getOrCreate(style.fontFamily).font; font.RequestCharactersInTexture(this._text.Substring(start, count), style.UnityFontSize, style.UnityFontStyle); this._advance = 0; this._bounds = null; for (int i = 0; i < count; i++) { int charIndex = start + i; var ch = text[charIndex]; CharacterInfo characterInfo; font.GetCharacterInfo(ch, out characterInfo, style.UnityFontSize, style.UnityFontStyle); var rect = Rect.fromLTRB(characterInfo.minX, -characterInfo.maxY, characterInfo.maxX, -characterInfo.minY); rect = rect.translate(this._advance, 0); if (this._bounds == null || this._bounds.isEmpty) { this._bounds = rect; } else { this._bounds = this._bounds.expandToInclude(rect); } this._positions.Add(this._advance); float advance = characterInfo.advance; if (ch == '\t') { advance = this._tabStops.nextTab((this._advance + offset)) - this._advance; } this._advances.Add(advance); this._advance += advance; } }
Rect _getRectFromDownStream(int offset, Rect caretPrototype) { string flattenedText = _text.toPlainText(includePlaceholders: false); var nextCodeUnit = _text.codeUnitAt(Mathf.Min(offset, flattenedText == null ? 0 : flattenedText.Length - 1)); if (nextCodeUnit == null) { return(null); } bool needsSearch = _isUtf16Surrogate(nextCodeUnit.Value) || nextCodeUnit == _zwjUtf16; int graphemeClusterLength = needsSearch ? 2 : 1; List <TextBox> boxes = null; while ((boxes == null || boxes.isEmpty()) && flattenedText != null) { int nextRuneOffset = offset + graphemeClusterLength; boxes = _paragraph.getBoxesForRange(offset, nextRuneOffset, boxHeightStyle: BoxHeightStyle.strut); if (boxes.isEmpty()) { if (!needsSearch) { break; } if (nextRuneOffset >= flattenedText.Length << 1) { break; } graphemeClusterLength *= 2; continue; } TextBox box = boxes[boxes.Count - 1]; float caretStart = box.start; float dx = box.direction == TextDirection.rtl ? caretStart - caretPrototype.width : caretStart; return(Rect.fromLTRB(Mathf.Min(dx, _paragraph.width()), box.top, Mathf.Min(dx, _paragraph.width()), box.bottom)); } return(null); }
public override void paint(Canvas canvas, Size size) { float selectedItemOffset = getSelectedItemOffset(); FloatTween top = new FloatTween( begin: selectedItemOffset.clamp(0.0f, size.height - material_._kMenuItemHeight), end: 0.0f ); FloatTween bottom = new FloatTween( begin: (top.begin + material_._kMenuItemHeight).clamp(material_._kMenuItemHeight, size.height), end: size.height ); Rect rect = Rect.fromLTRB(0.0f, top.evaluate(resize), size.width, bottom.evaluate(resize)); _painter.paint(canvas, rect.topLeft, new ImageConfiguration(size: rect.size)); }
public override void paint(Canvas canvas, Size size) { float selectedItemOffset = this.selectedIndex ?? 0 * DropdownConstants._kMenuItemHeight + Constants.kMaterialListPadding.top; FloatTween top = new FloatTween( begin: selectedItemOffset.clamp(0.0f, size.height - DropdownConstants._kMenuItemHeight), end: 0.0f ); FloatTween bottom = new FloatTween( begin: (top.begin + DropdownConstants._kMenuItemHeight).clamp(DropdownConstants._kMenuItemHeight, size.height), end: size.height ); Rect rect = Rect.fromLTRB(0.0f, top.evaluate(this.resize), size.width, bottom.evaluate(this.resize)); this._painter.paint(canvas, rect.topLeft, new ImageConfiguration(size: rect.size)); }
public Rect toRect() { return Rect.fromLTRB(this.left, this.top, this.right, this.bottom); }
public static Rect transformRect(Matrix4 transform, Rect rect) { float[] storage = transform.storage; float x = rect.left; float y = rect.top; float w = rect.right - x; float h = rect.bottom - y; if (!w.isFinite() || !h.isFinite()) { return(_safeTransformRect(transform, rect)); } float wx = storage[0] * w; float hx = storage[4] * h; float rx = storage[0] * x + storage[4] * y + storage[12]; float wy = storage[1] * w; float hy = storage[5] * h; float ry = storage[1] * x + storage[5] * y + storage[13]; if (storage[3] == 0.0f && storage[7] == 0.0f && storage[15] == 1.0f) { float left = rx; float right = rx; if (wx < 0) { left += wx; } else { right += wx; } if (hx < 0) { left += hx; } else { right += hx; } float top = ry; float bottom = ry; if (wy < 0) { top += wy; } else { bottom += wy; } if (hy < 0) { top += hy; } else { bottom += hy; } return(Rect.fromLTRB(left, top, right, bottom)); } else { float ww = storage[3] * w; float hw = storage[7] * h; float rw = storage[3] * x + storage[7] * y + storage[15]; float ulx = rx / rw; float uly = ry / rw; float urx = (rx + wx) / (rw + ww); float ury = (ry + wy) / (rw + ww); float llx = (rx + hx) / (rw + hw); float lly = (ry + hy) / (rw + hw); float lrx = (rx + wx + hx) / (rw + ww + hw); float lry = (ry + wy + hy) / (rw + ww + hw); return(Rect.fromLTRB( _min4(ulx, urx, llx, lrx), _min4(uly, ury, lly, lry), _max4(ulx, urx, llx, lrx), _max4(uly, ury, lly, lry) )); } }
void _drawValueIndicator( RenderBox parentBox, Canvas canvas, Offset center, Paint paint, float scale, TextPainter labelPainter ) { canvas.save(); canvas.translate(center.dx, center.dy); float textScaleFactor = labelPainter.height / _labelTextDesignSize; float overallScale = scale * textScaleFactor; canvas.scale(overallScale, overallScale); float inverseTextScale = textScaleFactor != 0 ? 1.0f / textScaleFactor : 0.0f; float labelHalfWidth = labelPainter.width / 2.0f; float halfWidthNeeded = Mathf.Max( 0.0f, inverseTextScale * labelHalfWidth - (_topLobeRadius - _labelPadding) ); float shift = this._getIdealOffset(parentBox, halfWidthNeeded, overallScale, center); float leftWidthNeeded; float rightWidthNeeded; if (shift < 0.0) { shift = Mathf.Max(shift, -halfWidthNeeded); } else { shift = Mathf.Min(shift, halfWidthNeeded); } rightWidthNeeded = halfWidthNeeded + shift; leftWidthNeeded = halfWidthNeeded - shift; Path path = new Path(); Offset bottomLobeEnd = this._addBottomLobe(path); float neckTriangleBase = _topNeckRadius - bottomLobeEnd.dx; float leftAmount = Mathf.Max(0.0f, Mathf.Min(1.0f, leftWidthNeeded / neckTriangleBase)); float rightAmount = Mathf.Max(0.0f, Mathf.Min(1.0f, rightWidthNeeded / neckTriangleBase)); float leftTheta = (1.0f - leftAmount) * _thirtyDegrees; float rightTheta = (1.0f - rightAmount) * _thirtyDegrees; Offset neckLeftCenter = new Offset( -neckTriangleBase, _topLobeCenter.dy + Mathf.Cos(leftTheta) * _neckTriangleHypotenuse ); Offset neckRightCenter = new Offset( neckTriangleBase, _topLobeCenter.dy + Mathf.Cos(rightTheta) * _neckTriangleHypotenuse ); float leftNeckArcAngle = _ninetyDegrees - leftTheta; float rightNeckArcAngle = Mathf.PI + _ninetyDegrees - rightTheta; float neckStretchBaseline = bottomLobeEnd.dy - Mathf.Max(neckLeftCenter.dy, neckRightCenter.dy); float t = Mathf.Pow(inverseTextScale, 3.0f); float stretch = (neckStretchBaseline * t).clamp(0.0f, 10.0f * neckStretchBaseline); Offset neckStretch = new Offset(0.0f, neckStretchBaseline - stretch); D.assert(() => { if (!_debuggingLabelLocation) { return(true); } #pragma warning disable 0162 Offset leftCenter = _topLobeCenter - new Offset(leftWidthNeeded, 0.0f) + neckStretch; Offset rightCenter = _topLobeCenter + new Offset(rightWidthNeeded, 0.0f) + neckStretch; Rect valueRect = Rect.fromLTRB( leftCenter.dx - _topLobeRadius, leftCenter.dy - _topLobeRadius, rightCenter.dx + _topLobeRadius, rightCenter.dy + _topLobeRadius ); Paint outlinePaint = new Paint(); outlinePaint.color = new Color(0xffff0000); outlinePaint.style = PaintingStyle.stroke; outlinePaint.strokeWidth = 1.0f; canvas.drawRect(valueRect, outlinePaint); return(true); #pragma warning restore 0162 }); _addArc( path, neckLeftCenter + neckStretch, _topNeckRadius, 0.0f, -leftNeckArcAngle ); _addArc( path, _topLobeCenter - new Offset(leftWidthNeeded, 0.0f) + neckStretch, _topLobeRadius, _ninetyDegrees + leftTheta, _twoSeventyDegrees ); _addArc( path, _topLobeCenter + new Offset(rightWidthNeeded, 0.0f) + neckStretch, _topLobeRadius, _twoSeventyDegrees, _twoSeventyDegrees + Mathf.PI - rightTheta ); _addArc( path, neckRightCenter + neckStretch, _topNeckRadius, rightNeckArcAngle, Mathf.PI ); canvas.drawPath(path, paint); canvas.save(); canvas.translate(shift, -_distanceBetweenTopBottomCenters + neckStretch.dy); canvas.scale(inverseTextScale, inverseTextScale); labelPainter.paint(canvas, Offset.zero - new Offset(labelHalfWidth, labelPainter.height / 2.0f)); canvas.restore(); canvas.restore(); }
bool _applyClip(Rect queryBounds) { var layer = this._currentLayer; var layerBounds = layer.layerBounds; ReducedClip reducedClip = new ReducedClip(layer.clipStack, layerBounds, queryBounds); if (reducedClip.isEmpty()) { return(false); } var scissor = reducedClip.scissor; var physicalRect = Rect.fromLTRB(0, 0, layer.width, layer.height); if (scissor == layerBounds) { this._tryAddScissor(layer, null); } else { var deviceScissor = Rect.fromLTRB( scissor.left - layerBounds.left, layerBounds.bottom - scissor.bottom, scissor.right - layerBounds.left, layerBounds.bottom - scissor.top ).scale(layer.width / layerBounds.width, layer.height / layerBounds.height); deviceScissor = deviceScissor.roundOut(); deviceScissor = deviceScissor.intersect(physicalRect); if (deviceScissor.isEmpty) { return(false); } this._tryAddScissor(layer, deviceScissor); } var maskGenID = reducedClip.maskGenID(); if (this._mustRenderClip(maskGenID, reducedClip.scissor)) { if (maskGenID == ClipStack.wideOpenGenID) { layer.ignoreClip = true; } else { layer.ignoreClip = false; var boundsMesh = new MeshMesh(reducedClip.scissor); layer.draws.Add(CanvasShader.stencilClear(layer, boundsMesh)); foreach (var maskElement in reducedClip.maskElements) { layer.draws.Add(CanvasShader.stencil0(layer, maskElement.mesh)); layer.draws.Add(CanvasShader.stencil1(layer, boundsMesh)); } } this._setLastClipGenId(maskGenID, reducedClip.scissor); } return(true); }
public override void paint(PaintingContext context, Offset offset) { Canvas canvas = context.canvas; float currentValue = this._position.value; float currentReactionValue = this._reaction.value; float visualPosition = 0f; switch (this.textDirection) { case TextDirection.rtl: visualPosition = 1.0f - currentValue; break; case TextDirection.ltr: visualPosition = currentValue; break; } Color trackColor = this._value ? this.activeColor : CupertinoSwitchUtils._kTrackColor; float borderThickness = 1.5f + (CupertinoSwitchUtils._kTrackRadius - 1.5f) * Mathf.Max(currentReactionValue, currentValue); Paint paint = new Paint(); paint.color = trackColor; Rect trackRect = Rect.fromLTWH( offset.dx + (this.size.width - CupertinoSwitchUtils._kTrackWidth) / 2.0f, offset.dy + (this.size.height - CupertinoSwitchUtils._kTrackHeight) / 2.0f, CupertinoSwitchUtils._kTrackWidth, CupertinoSwitchUtils._kTrackHeight ); RRect outerRRect = RRect.fromRectAndRadius(trackRect, Radius.circular(CupertinoSwitchUtils ._kTrackRadius)); RRect innerRRect = RRect.fromRectAndRadius(trackRect.deflate(borderThickness), Radius.circular (CupertinoSwitchUtils._kTrackRadius)); canvas.drawDRRect(outerRRect, innerRRect, paint); float currentThumbExtension = CupertinoThumbPainter.extension * currentReactionValue; float thumbLeft = MathUtils.lerpFloat( trackRect.left + CupertinoSwitchUtils._kTrackInnerStart - CupertinoThumbPainter.radius, trackRect.left + CupertinoSwitchUtils._kTrackInnerEnd - CupertinoThumbPainter.radius - currentThumbExtension, visualPosition ); float thumbRight = MathUtils.lerpFloat( trackRect.left + CupertinoSwitchUtils._kTrackInnerStart + CupertinoThumbPainter.radius + currentThumbExtension, trackRect.left + CupertinoSwitchUtils._kTrackInnerEnd + CupertinoThumbPainter.radius, visualPosition ); float thumbCenterY = offset.dy + this.size.height / 2.0f; this._thumbPainter.paint(canvas, Rect.fromLTRB( thumbLeft, thumbCenterY - CupertinoThumbPainter.radius, thumbRight, thumbCenterY + CupertinoThumbPainter.radius )); }
public override void paint(PaintingContext context, Offset offset) { Canvas canvas = context.canvas; float trackLength = this.size.width - 2 * _overlayRadius; float value = this._state.positionController.value; ColorTween activeTrackEnableColor = new ColorTween(begin: this._sliderTheme.disabledActiveTrackColor, end: this._sliderTheme.activeTrackColor); ColorTween inactiveTrackEnableColor = new ColorTween(begin: this._sliderTheme.disabledInactiveTrackColor, end: this._sliderTheme.inactiveTrackColor); ColorTween activeTickMarkEnableColor = new ColorTween(begin: this._sliderTheme.disabledActiveTickMarkColor, end: this._sliderTheme.activeTickMarkColor); ColorTween inactiveTickMarkEnableColor = new ColorTween(begin: this._sliderTheme.disabledInactiveTickMarkColor, end: this._sliderTheme.inactiveTickMarkColor); Paint activeTrackPaint = new Paint { color = activeTrackEnableColor.evaluate(this._enableAnimation) }; Paint inactiveTrackPaint = new Paint { color = inactiveTrackEnableColor.evaluate(this._enableAnimation) }; Paint activeTickMarkPaint = new Paint { color = activeTickMarkEnableColor.evaluate(this._enableAnimation) }; Paint inactiveTickMarkPaint = new Paint { color = inactiveTickMarkEnableColor.evaluate(this._enableAnimation) }; float visualPosition = value; Paint leftTrackPaint = activeTrackPaint; Paint rightTrackPaint = inactiveTrackPaint; Paint leftTickMarkPaint = activeTickMarkPaint; Paint rightTickMarkPaint = inactiveTickMarkPaint; float trackRadius = _trackHeight / 2.0f; float thumbGap = 2.0f; float trackVerticalCenter = offset.dy + (this.size.height) / 2.0f; float trackLeft = offset.dx + _overlayRadius; float trackTop = trackVerticalCenter - trackRadius; float trackBottom = trackVerticalCenter + trackRadius; float trackRight = trackLeft + trackLength; float trackActive = trackLeft + trackLength * visualPosition; float thumbRadius = this._sliderTheme.thumbShape.getPreferredSize(this.isInteractive, this.isDiscrete).width / 2.0f; float trackActiveLeft = Mathf.Max(0.0f, trackActive - thumbRadius - thumbGap * (1.0f - this._enableAnimation.value)); float trackActiveRight = Mathf.Min(trackActive + thumbRadius + thumbGap * (1.0f - this._enableAnimation.value), trackRight); Rect trackLeftRect = Rect.fromLTRB(trackLeft, trackTop, trackActiveLeft, trackBottom); Rect trackRightRect = Rect.fromLTRB(trackActiveRight, trackTop, trackRight, trackBottom); Offset thumbCenter = new Offset(trackActive, trackVerticalCenter); if (visualPosition > 0.0) { canvas.drawRect(trackLeftRect, leftTrackPaint); } if (visualPosition < 1.0) { canvas.drawRect(trackRightRect, rightTrackPaint); } this._paintOverlay(canvas, thumbCenter); this._paintTickMarks( canvas, trackLeftRect, trackRightRect, leftTickMarkPaint, rightTickMarkPaint ); if (this.isInteractive && this.label != null && this._valueIndicatorAnimation.status != AnimationStatus.dismissed) { if (this.showValueIndicator) { this._sliderTheme.valueIndicatorShape.paint( context, thumbCenter, activationAnimation: this._valueIndicatorAnimation, enableAnimation: this._enableAnimation, isDiscrete: this.isDiscrete, labelPainter: this._labelPainter, parentBox: this, sliderTheme: this._sliderTheme, value: this._value ); } } this._sliderTheme.thumbShape.paint( context, thumbCenter, activationAnimation: this._valueIndicatorAnimation, enableAnimation: this._enableAnimation, isDiscrete: this.isDiscrete, labelPainter: this._labelPainter, parentBox: this, sliderTheme: this._sliderTheme, value: this._value ); }
public override void paint(PaintingContext context, Offset offset) { base.paint(context, offset); Offset bottomRight = size.bottomRight(offset); Rect outer = Rect.fromLTRB(offset.dx, offset.dy, bottomRight.dx, bottomRight.dy); Rect center = outer.deflate(horizontalBorderSide.width / 2.0f); const float sweepAngle = Mathf.PI / 2.0f; RRect rrect = RRect.fromRectAndCorners( center, topLeft: borderRadius.topLeft, topRight: borderRadius.topRight, bottomLeft: borderRadius.bottomLeft, bottomRight: borderRadius.bottomRight ).scaleRadii(); Rect tlCorner = Rect.fromLTWH( rrect.left, rrect.top, rrect.tlRadiusX * 2.0f, rrect.tlRadiusY * 2.0f ); Rect blCorner = Rect.fromLTWH( rrect.left, rrect.bottom - (rrect.blRadiusY * 2.0f), rrect.blRadiusX * 2.0f, rrect.blRadiusY * 2.0f ); Rect trCorner = Rect.fromLTWH( rrect.right - (rrect.trRadiusX * 2.0f), rrect.top, rrect.trRadiusX * 2.0f, rrect.trRadiusY * 2.0f ); Rect brCorner = Rect.fromLTWH( rrect.right - (rrect.brRadiusX * 2.0f), rrect.bottom - (rrect.brRadiusY * 2.0f), rrect.brRadiusX * 2.0f, rrect.brRadiusY * 2.0f ); Paint leadingPaint = leadingBorderSide.toPaint(); switch (textDirection) { case TextDirection.ltr: { if (isLastButton) { Path leftPath = new Path(); leftPath.moveTo(rrect.left, rrect.bottom + leadingBorderSide.width / 2); leftPath.lineTo(rrect.left, rrect.top - leadingBorderSide.width / 2); context.canvas.drawPath(leftPath, leadingPaint); Paint endingPaint = trailingBorderSide.toPaint(); Path endingPath = new Path(); endingPath.moveTo(rrect.left + horizontalBorderSide.width / 2.0f, rrect.top); endingPath.lineTo(rrect.right - rrect.trRadiusX, rrect.top); endingPath.addArc(trCorner, Mathf.PI * 3.0f / 2.0f, sweepAngle); endingPath.lineTo(rrect.right, rrect.bottom - rrect.brRadiusY); endingPath.addArc(brCorner, 0, sweepAngle); endingPath.lineTo(rrect.left + horizontalBorderSide.width / 2.0f, rrect.bottom); context.canvas.drawPath(endingPath, endingPaint); } else if (isFirstButton) { Path leadingPath = new Path(); leadingPath.moveTo(outer.right, rrect.bottom); leadingPath.lineTo(rrect.left + rrect.blRadiusX, rrect.bottom); leadingPath.addArc(blCorner, Mathf.PI / 2.0f, sweepAngle); leadingPath.lineTo(rrect.left, rrect.top + rrect.tlRadiusY); leadingPath.addArc(tlCorner, Mathf.PI, sweepAngle); leadingPath.lineTo(outer.right, rrect.top); context.canvas.drawPath(leadingPath, leadingPaint); } else { Path leadingPath = new Path(); leadingPath.moveTo(rrect.left, rrect.bottom + leadingBorderSide.width / 2); leadingPath.lineTo(rrect.left, rrect.top - leadingBorderSide.width / 2); context.canvas.drawPath(leadingPath, leadingPaint); Paint horizontalPaint = horizontalBorderSide.toPaint(); Path horizontalPaths = new Path(); horizontalPaths.moveTo(rrect.left + horizontalBorderSide.width / 2.0f, rrect.top); horizontalPaths.lineTo(outer.right - rrect.trRadiusX, rrect.top); horizontalPaths.moveTo(rrect.left + horizontalBorderSide.width / 2.0f + rrect.tlRadiusX, rrect.bottom); horizontalPaths.lineTo(outer.right - rrect.trRadiusX, rrect.bottom); context.canvas.drawPath(horizontalPaths, horizontalPaint); } break; } case TextDirection.rtl: { if (isLastButton) { Path leadingPath = new Path(); leadingPath.moveTo(rrect.right, rrect.bottom + leadingBorderSide.width / 2); leadingPath.lineTo(rrect.right, rrect.top - leadingBorderSide.width / 2); context.canvas.drawPath(leadingPath, leadingPaint); Paint endingPaint = trailingBorderSide.toPaint(); Path endingPath = new Path(); endingPath.moveTo(rrect.right - horizontalBorderSide.width / 2.0f, rrect.top); endingPath.lineTo(rrect.left + rrect.tlRadiusX, rrect.top); endingPath.addArc(tlCorner, Mathf.PI * 3.0f / 2.0f, -sweepAngle); endingPath.lineTo(rrect.left, rrect.bottom - rrect.blRadiusY); endingPath.addArc(blCorner, Mathf.PI, -sweepAngle); endingPath.lineTo(rrect.right - horizontalBorderSide.width / 2.0f, rrect.bottom); context.canvas.drawPath(endingPath, endingPaint); } else if (isFirstButton) { Path leadingPath = new Path(); leadingPath.moveTo(outer.left, rrect.bottom); leadingPath.lineTo(rrect.right - rrect.brRadiusX, rrect.bottom); leadingPath.addArc(brCorner, Mathf.PI / 2.0f, -sweepAngle); leadingPath.lineTo(rrect.right, rrect.top + rrect.trRadiusY); leadingPath.addArc(trCorner, 0, -sweepAngle); leadingPath.lineTo(outer.left, rrect.top); context.canvas.drawPath(leadingPath, leadingPaint); } else { Path leadingPath = new Path(); leadingPath.moveTo(rrect.right, rrect.bottom + leadingBorderSide.width / 2); leadingPath.lineTo(rrect.right, rrect.top - leadingBorderSide.width / 2); context.canvas.drawPath(leadingPath, leadingPaint); Paint horizontalPaint = horizontalBorderSide.toPaint(); Path horizontalPaths = new Path(); horizontalPaths.moveTo(rrect.right - horizontalBorderSide.width / 2.0f, rrect.top); horizontalPaths.lineTo(outer.left - rrect.tlRadiusX, rrect.top); horizontalPaths.moveTo(rrect.right - horizontalBorderSide.width / 2.0f + rrect.trRadiusX, rrect.bottom); horizontalPaths.lineTo(outer.left - rrect.tlRadiusX, rrect.bottom); context.canvas.drawPath(horizontalPaths, horizontalPaint); } break; } } }
public Rect inflateRect(Rect rect) { return(Rect.fromLTRB( rect.left - left, rect.top - top, rect.right + right, rect.bottom + bottom)); }
public Rect deflateRect(Rect rect) { return(Rect.fromLTRB( rect.left + left, rect.top + top, rect.right - right, rect.bottom - bottom)); }