/// <summary>Measures the child elements of a <see cref="T:System.Windows.Controls.Border" /> before they are arranged during the <see cref="M:System.Windows.Controls.Border.ArrangeOverride(System.Windows.Size)" /> pass.</summary> /// <param name="constraint">An upper <see cref="T:System.Windows.Size" /> limit that cannot be exceeded.</param> /// <returns>The <see cref="T:System.Windows.Size" /> that represents the upper size limit of the element.</returns> // Token: 0x06004264 RID: 16996 RVA: 0x0012F824 File Offset: 0x0012DA24 protected override Size MeasureOverride(Size constraint) { UIElement child = this.Child; Size result = default(Size); Thickness borderThickness = this.BorderThickness; if (base.UseLayoutRounding && !FrameworkAppContextSwitches.DoNotApplyLayoutRoundingToMarginsAndBorderThickness) { DpiScale dpi = base.GetDpi(); borderThickness = new Thickness(UIElement.RoundLayoutValue(borderThickness.Left, dpi.DpiScaleX), UIElement.RoundLayoutValue(borderThickness.Top, dpi.DpiScaleY), UIElement.RoundLayoutValue(borderThickness.Right, dpi.DpiScaleX), UIElement.RoundLayoutValue(borderThickness.Bottom, dpi.DpiScaleY)); } Size size = Border.HelperCollapseThickness(borderThickness); Size size2 = Border.HelperCollapseThickness(this.Padding); if (child != null) { Size size3 = new Size(size.Width + size2.Width, size.Height + size2.Height); Size availableSize = new Size(Math.Max(0.0, constraint.Width - size3.Width), Math.Max(0.0, constraint.Height - size3.Height)); child.Measure(availableSize); Size desiredSize = child.DesiredSize; result.Width = desiredSize.Width + size3.Width; result.Height = desiredSize.Height + size3.Height; } else { result = new Size(size.Width + size2.Width, size.Height + size2.Height); } return(result); }
// Token: 0x06004DDF RID: 19935 RVA: 0x0015F644 File Offset: 0x0015D844 private void MoveSplitter(double horizontalChange, double verticalChange) { DpiScale dpi = base.GetDpi(); double num; if (this._resizeData.ResizeDirection == GridResizeDirection.Columns) { num = horizontalChange; if (base.UseLayoutRounding) { num = UIElement.RoundLayoutValue(num, dpi.DpiScaleX); } } else { num = verticalChange; if (base.UseLayoutRounding) { num = UIElement.RoundLayoutValue(num, dpi.DpiScaleY); } } DefinitionBase definition = this._resizeData.Definition1; DefinitionBase definition2 = this._resizeData.Definition2; if (definition != null && definition2 != null) { double actualLength = this.GetActualLength(definition); double actualLength2 = this.GetActualLength(definition2); if (this._resizeData.SplitBehavior == GridSplitter.SplitBehavior.Split && !LayoutDoubleUtil.AreClose(actualLength + actualLength2, this._resizeData.OriginalDefinition1ActualLength + this._resizeData.OriginalDefinition2ActualLength)) { this.CancelResize(); return; } double val; double val2; this.GetDeltaConstraints(out val, out val2); if (base.FlowDirection != this._resizeData.Grid.FlowDirection) { num = -num; } num = Math.Min(Math.Max(num, val), val2); double num2 = actualLength + num; double definition2Pixels = actualLength + actualLength2 - num2; this.SetLengths(num2, definition2Pixels); } }
//------------------------------------------------------------------- // // Protected Methods // //------------------------------------------------------------------- #region Protected Methods /// <summary> /// Updates DesiredSize of the Border. Called by parent UIElement. This is the first pass of layout. /// </summary> /// <remarks> /// Border determines its desired size it needs from the specified border the child: its sizing /// properties, margin, and requested size. /// </remarks> /// <param name="constraint">Constraint size is an "upper limit" that the return value should not exceed.</param> /// <returns>The Decorator's desired size.</returns> protected override Size MeasureOverride(Size constraint) { UIElement child = Child; Size mySize = new Size(); Thickness borders = this.BorderThickness; if (this.UseLayoutRounding && !FrameworkAppContextSwitches.DoNotApplyLayoutRoundingToMarginsAndBorderThickness) { double dpiScaleX = FrameworkElement.DpiScaleX; double dpiScaleY = FrameworkElement.DpiScaleY; borders = new Thickness(UIElement.RoundLayoutValue(borders.Left, dpiScaleX), UIElement.RoundLayoutValue(borders.Top, dpiScaleY), UIElement.RoundLayoutValue(borders.Right, dpiScaleX), UIElement.RoundLayoutValue(borders.Bottom, dpiScaleY)); } // Compute the chrome size added by the various elements Size border = HelperCollapseThickness(borders); Size padding = HelperCollapseThickness(this.Padding); //If we have a child if (child != null) { // Combine into total decorating size Size combined = new Size(border.Width + padding.Width, border.Height + padding.Height); // Remove size of border only from child's reference size. Size childConstraint = new Size(Math.Max(0.0, constraint.Width - combined.Width), Math.Max(0.0, constraint.Height - combined.Height)); child.Measure(childConstraint); Size childSize = child.DesiredSize; // Now use the returned size to drive our size, by adding back the margins, etc. mySize.Width = childSize.Width + combined.Width; mySize.Height = childSize.Height + combined.Height; } else { // Combine into total decorating size mySize = new Size(border.Width + padding.Width, border.Height + padding.Height); } return(mySize); }
// Move the splitter by the given Delta's in the horizontal and vertical directions private void MoveSplitter(double horizontalChange, double verticalChange) { Debug.Assert(_resizeData != null, "_resizeData should not be null when calling MoveSplitter"); double delta; DpiScale dpi = GetDpi(); // Calculate the offset to adjust the splitter. If layout rounding is enabled, we // need to round to an integer physical pixel value to avoid round-ups of children that // expand the bounds of the Grid. In practice this only happens in high dpi because // horizontal/vertical offsets here are never fractional (they correspond to mouse movement // across logical pixels). Rounding error only creeps in when converting to a physical // display with something other than the logical 96 dpi. if (_resizeData.ResizeDirection == GridResizeDirection.Columns) { delta = horizontalChange; if (this.UseLayoutRounding) { delta = UIElement.RoundLayoutValue(delta, dpi.DpiScaleX); } } else { delta = verticalChange; if (this.UseLayoutRounding) { delta = UIElement.RoundLayoutValue(delta, dpi.DpiScaleY); } } DefinitionBase definition1 = _resizeData.Definition1; DefinitionBase definition2 = _resizeData.Definition2; if (definition1 != null && definition2 != null) { double actualLength1 = GetActualLength(definition1); double actualLength2 = GetActualLength(definition2); // When splitting, Check to see if the total pixels spanned by the definitions // is the same asbefore starting resize. If not cancel the drag if (_resizeData.SplitBehavior == SplitBehavior.Split && !LayoutDoubleUtil.AreClose(actualLength1 + actualLength2, _resizeData.OriginalDefinition1ActualLength + _resizeData.OriginalDefinition2ActualLength)) { CancelResize(); return; } double min, max; GetDeltaConstraints(out min, out max); // Flip when the splitter's flow direction isn't the same as the grid's if (FlowDirection != _resizeData.Grid.FlowDirection) { delta = -delta; } // Constrain Delta to Min/MaxWidth of columns delta = Math.Min(Math.Max(delta, min), max); // With floating point operations there may be loss of precision to some degree. Eg. Adding a very // small value to a very large one might result in the small value being ignored. In the following // steps there are two floating point operations viz. actualLength1+delta and actualLength2-delta. // It is possible that the addition resulted in loss of precision and the delta value was ignored, whereas // the subtraction actual absorbed the delta value. This now means that // (definition1LengthNew + definition2LengthNewis) 2 factors of precision away from // (actualLength1 + actualLength2). This can cause a problem in the subsequent drag iteration where // this will be interpreted as the cancellation of the resize operation. To avoid this imprecision we use // make definition2LengthNew be a function of definition1LengthNew so that the precision or the loss // thereof can be counterbalanced. See DevDiv bug#140228 for a manifestation of this problem. double definition1LengthNew = actualLength1 + delta; //double definition2LengthNew = actualLength2 - delta; double definition2LengthNew = actualLength1 + actualLength2 - definition1LengthNew; SetLengths(definition1LengthNew, definition2LengthNew); } }
/// <summary> /// In addition to the child, Border renders a background + border. The background is drawn inside the border. /// </summary> protected override void OnRender(DrawingContext dc) { bool useLayoutRounding = this.UseLayoutRounding; DpiScale dpi = GetDpi(); if (_useComplexRenderCodePath) { Brush brush; StreamGeometry borderGeometry = BorderGeometryCache; if (borderGeometry != null && (brush = BorderBrush) != null) { dc.DrawGeometry(brush, null, borderGeometry); } StreamGeometry backgroundGeometry = BackgroundGeometryCache; if (backgroundGeometry != null && (brush = Background) != null) { dc.DrawGeometry(brush, null, backgroundGeometry); } } else { Thickness border = BorderThickness; Brush borderBrush; CornerRadius cornerRadius = CornerRadius; double outerCornerRadius = cornerRadius.TopLeft; // Already validated that all corners have the same radius bool roundedCorners = !DoubleUtil.IsZero(outerCornerRadius); // If we have a brush with which to draw the border, do so. // NB: We double draw corners right now. Corner handling is tricky (bevelling, &c...) and // we need a firm spec before doing "the right thing." (greglett, ffortes) if (!border.IsZero && (borderBrush = BorderBrush) != null) { // Initialize the first pen. Note that each pen is created via new() // and frozen if possible. Doing this avoids the pen // being copied when used in the DrawLine methods. Pen pen = LeftPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Left, dpi.DpiScaleX); } else { pen.Thickness = border.Left; } if (borderBrush.IsFrozen) { pen.Freeze(); } LeftPenCache = pen; } double halfThickness; if (border.IsUniform) { halfThickness = pen.Thickness * 0.5; // Create rect w/ border thickness, and round if applying layout rounding. Rect rect = new Rect(new Point(halfThickness, halfThickness), new Point(RenderSize.Width - halfThickness, RenderSize.Height - halfThickness)); if (roundedCorners) { dc.DrawRoundedRectangle( null, pen, rect, outerCornerRadius, outerCornerRadius); } else { dc.DrawRectangle( null, pen, rect); } } else { // Nonuniform border; stroke each edge. if (DoubleUtil.GreaterThan(border.Left, 0)) { halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(halfThickness, 0), new Point(halfThickness, RenderSize.Height)); } if (DoubleUtil.GreaterThan(border.Right, 0)) { pen = RightPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Right, dpi.DpiScaleX); } else { pen.Thickness = border.Right; } if (borderBrush.IsFrozen) { pen.Freeze(); } RightPenCache = pen; } halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(RenderSize.Width - halfThickness, 0), new Point(RenderSize.Width - halfThickness, RenderSize.Height)); } if (DoubleUtil.GreaterThan(border.Top, 0)) { pen = TopPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Top, dpi.DpiScaleY); } else { pen.Thickness = border.Top; } if (borderBrush.IsFrozen) { pen.Freeze(); } TopPenCache = pen; } halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(0, halfThickness), new Point(RenderSize.Width, halfThickness)); } if (DoubleUtil.GreaterThan(border.Bottom, 0)) { pen = BottomPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Bottom, dpi.DpiScaleY); } else { pen.Thickness = border.Bottom; } if (borderBrush.IsFrozen) { pen.Freeze(); } BottomPenCache = pen; } halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(0, RenderSize.Height - halfThickness), new Point(RenderSize.Width, RenderSize.Height - halfThickness)); } } } // Draw background in rectangle inside border. Brush background = Background; if (background != null) { // Intialize background Point ptTL, ptBR; if (useLayoutRounding) { ptTL = new Point(UIElement.RoundLayoutValue(border.Left, dpi.DpiScaleX), UIElement.RoundLayoutValue(border.Top, dpi.DpiScaleY)); if (FrameworkAppContextSwitches.DoNotApplyLayoutRoundingToMarginsAndBorderThickness) { ptBR = new Point(UIElement.RoundLayoutValue(RenderSize.Width - border.Right, dpi.DpiScaleX), UIElement.RoundLayoutValue(RenderSize.Height - border.Bottom, dpi.DpiScaleY)); } else { ptBR = new Point(RenderSize.Width - UIElement.RoundLayoutValue(border.Right, dpi.DpiScaleX), RenderSize.Height - UIElement.RoundLayoutValue(border.Bottom, dpi.DpiScaleY)); } } else { ptTL = new Point(border.Left, border.Top); ptBR = new Point(RenderSize.Width - border.Right, RenderSize.Height - border.Bottom); } // Do not draw background if the borders are so large that they overlap. if (ptBR.X > ptTL.X && ptBR.Y > ptTL.Y) { if (roundedCorners) { Radii innerRadii = new Radii(cornerRadius, border, false); // Determine the inner edge radius double innerCornerRadius = innerRadii.TopLeft; // Already validated that all corners have the same radius dc.DrawRoundedRectangle(background, null, new Rect(ptTL, ptBR), innerCornerRadius, innerCornerRadius); } else { dc.DrawRectangle(background, null, new Rect(ptTL, ptBR)); } } } } }
/// <summary> /// Border computes the position of its single child and applies its child's alignments to the child. /// /// </summary> /// <param name="finalSize">The size reserved for this element by the parent</param> /// <returns>The actual ink area of the element, typically the same as finalSize</returns> protected override Size ArrangeOverride(Size finalSize) { Thickness borders = BorderThickness; if (this.UseLayoutRounding && !FrameworkAppContextSwitches.DoNotApplyLayoutRoundingToMarginsAndBorderThickness) { DpiScale dpi = GetDpi(); borders = new Thickness(UIElement.RoundLayoutValue(borders.Left, dpi.DpiScaleX), UIElement.RoundLayoutValue(borders.Top, dpi.DpiScaleY), UIElement.RoundLayoutValue(borders.Right, dpi.DpiScaleX), UIElement.RoundLayoutValue(borders.Bottom, dpi.DpiScaleY)); } Rect boundRect = new Rect(finalSize); Rect innerRect = HelperDeflateRect(boundRect, borders); // arrange child UIElement child = Child; if (child != null) { Rect childRect = HelperDeflateRect(innerRect, Padding); child.Arrange(childRect); } CornerRadius radii = CornerRadius; Brush borderBrush = BorderBrush; bool uniformCorners = AreUniformCorners(radii); // decide which code path to execute. complex (geometry path based) rendering // is used if one of the following is true: // 1. there are non-uniform rounded corners _useComplexRenderCodePath = !uniformCorners; if (!_useComplexRenderCodePath && borderBrush != null) { SolidColorBrush originIndependentBrush = borderBrush as SolidColorBrush; bool uniformBorders = borders.IsUniform; _useComplexRenderCodePath = // 2. the border brush is origin dependent (the only origin independent brush is a solid color brush) (originIndependentBrush == null) // 3. the border brush is semi-transtarent solid color brush AND border thickness is not uniform // (for uniform semi-transparent border Border.OnRender draws rectangle outline - so it works fine) || ((originIndependentBrush.Color.A < 0xff) && !uniformBorders) // 4. there are rounded corners AND the border thickness is not uniform || (!DoubleUtil.IsZero(radii.TopLeft) && !uniformBorders); } if (_useComplexRenderCodePath) { Radii innerRadii = new Radii(radii, borders, false); StreamGeometry backgroundGeometry = null; // calculate border / background rendering geometry if (!DoubleUtil.IsZero(innerRect.Width) && !DoubleUtil.IsZero(innerRect.Height)) { backgroundGeometry = new StreamGeometry(); using (StreamGeometryContext ctx = backgroundGeometry.Open()) { GenerateGeometry(ctx, innerRect, innerRadii); } backgroundGeometry.Freeze(); BackgroundGeometryCache = backgroundGeometry; } else { BackgroundGeometryCache = null; } if (!DoubleUtil.IsZero(boundRect.Width) && !DoubleUtil.IsZero(boundRect.Height)) { Radii outerRadii = new Radii(radii, borders, true); StreamGeometry borderGeometry = new StreamGeometry(); using (StreamGeometryContext ctx = borderGeometry.Open()) { GenerateGeometry(ctx, boundRect, outerRadii); if (backgroundGeometry != null) { GenerateGeometry(ctx, innerRect, innerRadii); } } borderGeometry.Freeze(); BorderGeometryCache = borderGeometry; } else { BorderGeometryCache = null; } } else { BackgroundGeometryCache = null; BorderGeometryCache = null; } return(finalSize); }
/// <summary>Draws the contents of a <see cref="T:System.Windows.Media.DrawingContext" /> object during the render pass of a <see cref="T:System.Windows.Controls.Border" />. </summary> /// <param name="dc">The <see cref="T:System.Windows.Media.DrawingContext" /> that defines the object to be drawn.</param> // Token: 0x06004266 RID: 16998 RVA: 0x0012FBE0 File Offset: 0x0012DDE0 protected override void OnRender(DrawingContext dc) { bool useLayoutRounding = base.UseLayoutRounding; DpiScale dpi = base.GetDpi(); if (this._useComplexRenderCodePath) { StreamGeometry borderGeometryCache = this.BorderGeometryCache; Brush brush; if (borderGeometryCache != null && (brush = this.BorderBrush) != null) { dc.DrawGeometry(brush, null, borderGeometryCache); } StreamGeometry backgroundGeometryCache = this.BackgroundGeometryCache; if (backgroundGeometryCache != null && (brush = this.Background) != null) { dc.DrawGeometry(brush, null, backgroundGeometryCache); return; } } else { Thickness borderThickness = this.BorderThickness; CornerRadius cornerRadius = this.CornerRadius; double topLeft = cornerRadius.TopLeft; bool flag = !DoubleUtil.IsZero(topLeft); Brush borderBrush; if (!borderThickness.IsZero && (borderBrush = this.BorderBrush) != null) { Pen pen = this.LeftPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(borderThickness.Left, dpi.DpiScaleX); } else { pen.Thickness = borderThickness.Left; } if (borderBrush.IsFrozen) { pen.Freeze(); } this.LeftPenCache = pen; } if (borderThickness.IsUniform) { double num = pen.Thickness * 0.5; Rect rectangle = new Rect(new Point(num, num), new Point(base.RenderSize.Width - num, base.RenderSize.Height - num)); if (flag) { dc.DrawRoundedRectangle(null, pen, rectangle, topLeft, topLeft); } else { dc.DrawRectangle(null, pen, rectangle); } } else { if (DoubleUtil.GreaterThan(borderThickness.Left, 0.0)) { double num = pen.Thickness * 0.5; dc.DrawLine(pen, new Point(num, 0.0), new Point(num, base.RenderSize.Height)); } if (DoubleUtil.GreaterThan(borderThickness.Right, 0.0)) { pen = this.RightPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(borderThickness.Right, dpi.DpiScaleX); } else { pen.Thickness = borderThickness.Right; } if (borderBrush.IsFrozen) { pen.Freeze(); } this.RightPenCache = pen; } double num = pen.Thickness * 0.5; dc.DrawLine(pen, new Point(base.RenderSize.Width - num, 0.0), new Point(base.RenderSize.Width - num, base.RenderSize.Height)); } if (DoubleUtil.GreaterThan(borderThickness.Top, 0.0)) { pen = this.TopPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(borderThickness.Top, dpi.DpiScaleY); } else { pen.Thickness = borderThickness.Top; } if (borderBrush.IsFrozen) { pen.Freeze(); } this.TopPenCache = pen; } double num = pen.Thickness * 0.5; dc.DrawLine(pen, new Point(0.0, num), new Point(base.RenderSize.Width, num)); } if (DoubleUtil.GreaterThan(borderThickness.Bottom, 0.0)) { pen = this.BottomPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(borderThickness.Bottom, dpi.DpiScaleY); } else { pen.Thickness = borderThickness.Bottom; } if (borderBrush.IsFrozen) { pen.Freeze(); } this.BottomPenCache = pen; } double num = pen.Thickness * 0.5; dc.DrawLine(pen, new Point(0.0, base.RenderSize.Height - num), new Point(base.RenderSize.Width, base.RenderSize.Height - num)); } } } Brush background = this.Background; if (background != null) { Point point; Point point2; if (useLayoutRounding) { point = new Point(UIElement.RoundLayoutValue(borderThickness.Left, dpi.DpiScaleX), UIElement.RoundLayoutValue(borderThickness.Top, dpi.DpiScaleY)); if (FrameworkAppContextSwitches.DoNotApplyLayoutRoundingToMarginsAndBorderThickness) { point2 = new Point(UIElement.RoundLayoutValue(base.RenderSize.Width - borderThickness.Right, dpi.DpiScaleX), UIElement.RoundLayoutValue(base.RenderSize.Height - borderThickness.Bottom, dpi.DpiScaleY)); } else { point2 = new Point(base.RenderSize.Width - UIElement.RoundLayoutValue(borderThickness.Right, dpi.DpiScaleX), base.RenderSize.Height - UIElement.RoundLayoutValue(borderThickness.Bottom, dpi.DpiScaleY)); } } else { point = new Point(borderThickness.Left, borderThickness.Top); point2 = new Point(base.RenderSize.Width - borderThickness.Right, base.RenderSize.Height - borderThickness.Bottom); } if (point2.X > point.X && point2.Y > point.Y) { if (flag) { Border.Radii radii = new Border.Radii(cornerRadius, borderThickness, false); double topLeft2 = radii.TopLeft; dc.DrawRoundedRectangle(background, null, new Rect(point, point2), topLeft2, topLeft2); return; } dc.DrawRectangle(background, null, new Rect(point, point2)); } } } }
/// <summary>Arranges the contents of a <see cref="T:System.Windows.Controls.Border" /> element.</summary> /// <param name="finalSize">The <see cref="T:System.Windows.Size" /> this element uses to arrange its child element.</param> /// <returns>The <see cref="T:System.Windows.Size" /> that represents the arranged size of this <see cref="T:System.Windows.Controls.Border" /> element and its child element.</returns> // Token: 0x06004265 RID: 16997 RVA: 0x0012F998 File Offset: 0x0012DB98 protected override Size ArrangeOverride(Size finalSize) { Thickness borderThickness = this.BorderThickness; if (base.UseLayoutRounding && !FrameworkAppContextSwitches.DoNotApplyLayoutRoundingToMarginsAndBorderThickness) { DpiScale dpi = base.GetDpi(); borderThickness = new Thickness(UIElement.RoundLayoutValue(borderThickness.Left, dpi.DpiScaleX), UIElement.RoundLayoutValue(borderThickness.Top, dpi.DpiScaleY), UIElement.RoundLayoutValue(borderThickness.Right, dpi.DpiScaleX), UIElement.RoundLayoutValue(borderThickness.Bottom, dpi.DpiScaleY)); } Rect rect = new Rect(finalSize); Rect rect2 = Border.HelperDeflateRect(rect, borderThickness); UIElement child = this.Child; if (child != null) { Rect finalRect = Border.HelperDeflateRect(rect2, this.Padding); child.Arrange(finalRect); } CornerRadius cornerRadius = this.CornerRadius; Brush borderBrush = this.BorderBrush; bool flag = Border.AreUniformCorners(cornerRadius); this._useComplexRenderCodePath = !flag; if (!this._useComplexRenderCodePath && borderBrush != null) { SolidColorBrush solidColorBrush = borderBrush as SolidColorBrush; bool isUniform = borderThickness.IsUniform; this._useComplexRenderCodePath = (solidColorBrush == null || (solidColorBrush.Color.A < byte.MaxValue && !isUniform) || (!DoubleUtil.IsZero(cornerRadius.TopLeft) && !isUniform)); } if (this._useComplexRenderCodePath) { Border.Radii radii = new Border.Radii(cornerRadius, borderThickness, false); StreamGeometry streamGeometry = null; if (!DoubleUtil.IsZero(rect2.Width) && !DoubleUtil.IsZero(rect2.Height)) { streamGeometry = new StreamGeometry(); using (StreamGeometryContext streamGeometryContext = streamGeometry.Open()) { Border.GenerateGeometry(streamGeometryContext, rect2, radii); } streamGeometry.Freeze(); this.BackgroundGeometryCache = streamGeometry; } else { this.BackgroundGeometryCache = null; } if (!DoubleUtil.IsZero(rect.Width) && !DoubleUtil.IsZero(rect.Height)) { Border.Radii radii2 = new Border.Radii(cornerRadius, borderThickness, true); StreamGeometry streamGeometry2 = new StreamGeometry(); using (StreamGeometryContext streamGeometryContext2 = streamGeometry2.Open()) { Border.GenerateGeometry(streamGeometryContext2, rect, radii2); if (streamGeometry != null) { Border.GenerateGeometry(streamGeometryContext2, rect2, radii); } } streamGeometry2.Freeze(); this.BorderGeometryCache = streamGeometry2; } else { this.BorderGeometryCache = null; } } else { this.BackgroundGeometryCache = null; this.BorderGeometryCache = null; } return(finalSize); }