/// <summary> /// Convert a value. Called when moving a value from source to target. /// </summary> /// <param name="values">values as produced by source binding</param> /// <param name="targetType">target type</param> /// <param name="parameter">converter parameter</param> /// <param name="culture">culture information</param> /// <returns> /// Converted value. /// /// System.Windows.DependencyProperty.UnsetValue may be returned to indicate that /// the converter produced no value and that the fallback (if available) /// or default value should be used instead. /// /// Binding.DoNothing may be returned to indicate that the binding /// should not transfer the value or use the fallback or default value. /// </returns> public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) { // // Parameter Validation // if (parameter == null || values == null || values.Length != 4 || values[0] is not Visibility || values[1] is not double || values[2] is not double || values[3] is not double) { return(DependencyProperty.UnsetValue); } if (parameter is not double && parameter is not string) { return(DependencyProperty.UnsetValue); } // // Conversion // // If the scroll bar should be visible, then so should our buttons Visibility computedVerticalScrollBarVisibility = (Visibility)values[0]; if (computedVerticalScrollBarVisibility == Visibility.Visible) { double target; if (parameter is string) { target = Double.Parse(((string)parameter), NumberFormatInfo.InvariantInfo); } else { target = (double)parameter; } double verticalOffset = (double)values[1]; double extentHeight = (double)values[2]; double viewportHeight = (double)values[3]; if (extentHeight != viewportHeight) // Avoid divide by 0 { // Calculate the percent so that we can see if we are near the edge of the range double percent = Math.Min(100.0, Math.Max(0.0, (verticalOffset * 100.0 / (extentHeight - viewportHeight)))); if (DoubleUtil.AreClose(percent, target)) { // We are at the end of the range, so no need for this button to be shown return(Visibility.Collapsed); } } return(Visibility.Visible); } return(Visibility.Collapsed); }
/// <summary> /// Parses a DataGridLength from a string given the CultureInfo. /// </summary> /// <param name="s">String to parse from.</param> /// <param name="cultureInfo">Culture Info.</param> /// <returns>Newly created DataGridLength instance.</returns> /// <remarks> /// Formats: /// "[value][unit]" /// [value] is a double /// [unit] is a string in DataGridLength._unitTypes connected to a DataGridLengthUnitType /// "[value]" /// As above, but the DataGridLengthUnitType is assumed to be DataGridLengthUnitType.Pixel /// "[unit]" /// As above, but the value is assumed to be 1.0 /// This is only acceptable for a subset of DataGridLengthUnitType: Auto /// </remarks> private static DataGridLength ConvertFromString(string s, CultureInfo cultureInfo) { string goodString = s.Trim().ToLowerInvariant(); // Check if the string matches any of the descriptive unit types. // In these cases, there is no need to parse a value. for (int i = 0; i < NumDescriptiveUnits; i++) { string unitString = _unitStrings[i]; if (goodString == unitString) { return(new DataGridLength(1.0, (DataGridLengthUnitType)i)); } } double value = 0.0; DataGridLengthUnitType unit = DataGridLengthUnitType.Pixel; int strLen = goodString.Length; int strLenUnit = 0; double unitFactor = 1.0; // Check if the string contains a non-descriptive unit at the end. int numUnitStrings = _unitStrings.Length; for (int i = NumDescriptiveUnits; i < numUnitStrings; i++) { string unitString = _unitStrings[i]; // Note: This is NOT a culture specific comparison. // This is by design: we want the same unit string table to work across all cultures. if (goodString.EndsWith(unitString, StringComparison.Ordinal)) { strLenUnit = unitString.Length; unit = (DataGridLengthUnitType)i; break; } } // Couldn't match a standard unit type, try a non-standard unit type. if (strLenUnit == 0) { numUnitStrings = _nonStandardUnitStrings.Length; for (int i = 0; i < numUnitStrings; i++) { string unitString = _nonStandardUnitStrings[i]; // Note: This is NOT a culture specific comparison. // This is by design: we want the same unit string table to work across all cultures. if (goodString.EndsWith(unitString, StringComparison.Ordinal)) { strLenUnit = unitString.Length; unitFactor = _pixelUnitFactors[i]; break; } } } // Check if there is a numerical value to parse if (strLen == strLenUnit) { // There is no numerical value to parse if (unit == DataGridLengthUnitType.Star) { // Star's value defaults to 1. Anyone else would be 0. value = 1.0; } } else { // Parse a numerical value Debug.Assert( (unit == DataGridLengthUnitType.Pixel) || DoubleUtil.AreClose(unitFactor, 1.0), "unitFactor should not be other than 1.0 unless the unit type is Pixel."); string valueString = goodString.Substring(0, strLen - strLenUnit); value = Convert.ToDouble(valueString, cultureInfo) * unitFactor; } return(new DataGridLength(value, unit)); }
/// <summary> /// Compares two Vector instances for fuzzy equality. This function /// helps compensate for the fact that double values can /// acquire error when operated upon /// </summary> /// <param name="vector1">The first Vector to compare /// <param name="vector2">The second Vector to compare /// <returns>Whether or not the two Vector instances are equal</returns> public static bool AreClose(System.Windows.Vector vector1, System.Windows.Vector vector2) { return(DoubleUtil.AreClose(vector1.X, vector2.X) && DoubleUtil.AreClose(vector1.Y, vector2.Y)); }
/// <summary> /// Compares two Size instances for fuzzy equality. This function /// helps compensate for the fact that double values can /// acquire error when operated upon /// </summary> /// <param name="size1">The first size to compare /// <param name="size2">The second size to compare /// <returns>Whether or not the two Size instances are equal</returns> public static bool AreClose(Size size1, Size size2) { return(DoubleUtil.AreClose(size1.Width, size2.Width) && DoubleUtil.AreClose(size1.Height, size2.Height)); }
// The Point, Size, Rect and Matrix class have moved to WinCorLib. However, we provide // internal AreClose methods for our own use here. /// <summary> /// Compares two points for fuzzy equality. This function /// helps compensate for the fact that double values can /// acquire error when operated upon /// </summary> /// <param name="point1">The first point to compare /// <param name="point2">The second point to compare /// <returns>Whether or not the two points are equal</returns> public static bool AreClose(Point point1, Point point2) { return(DoubleUtil.AreClose(point1.X, point2.X) && DoubleUtil.AreClose(point1.Y, point2.Y)); }
// Token: 0x06004268 RID: 17000 RVA: 0x001301EC File Offset: 0x0012E3EC private static bool AreUniformCorners(CornerRadius borderRadii) { double topLeft = borderRadii.TopLeft; return(DoubleUtil.AreClose(topLeft, borderRadii.TopRight) && DoubleUtil.AreClose(topLeft, borderRadii.BottomLeft) && DoubleUtil.AreClose(topLeft, borderRadii.BottomRight)); }
/// <summary> /// OnLayoutUpdated handler. Validates that all participating definitions /// have updated min size value. Forces another layout update cycle if needed. /// </summary> private void OnLayoutUpdated(object sender, EventArgs e) { double sharedMinSize = 0; // accumulate min size of all participating definitions for (int i = 0, count = _registry.Count; i < count; ++i) { sharedMinSize = Math.Max(sharedMinSize, _registry[i]._minSize); } bool sharedMinSizeChanged = !DoubleUtil.AreClose(_minSize, sharedMinSize); // compare accumulated min size with min sizes of the individual definitions for (int i = 0, count = _registry.Count; i < count; ++i) { DefinitionBase definitionBase = _registry[i]; // we'll set d.UseSharedMinimum to maintain the invariant: // d.UseSharedMinimum iff d._minSize < this.MinSize // i.e. iff d is not a "long-pole" definition. // // Measure/Arrange of d's Grid uses d._minSize for long-pole // definitions, and max(d._minSize, shared size) for // short-pole definitions. This distinction allows us to react // to changes in "long-pole-ness" more efficiently and correctly, // by avoiding remeasures when a long-pole definition changes. bool useSharedMinimum = !DoubleUtil.AreClose(definitionBase._minSize, sharedMinSize); // before doing that, determine whether d's Grid needs to be remeasured. // It's important _not_ to remeasure if the last measure is still // valid, otherwise infinite loops are possible bool measureIsValid; if (!definitionBase.UseSharedMinimum) { // d was a long-pole. measure is valid iff it's still a long-pole, // since previous measure didn't use shared size. measureIsValid = !useSharedMinimum; } else if (useSharedMinimum) { // d was a short-pole, and still is. measure is valid // iff the shared size didn't change measureIsValid = !sharedMinSizeChanged; } else { // d was a short-pole, but is now a long-pole. This can // happen in several ways: // a. d's minSize increased to or past the old shared size // b. other long-pole definitions decreased, leaving // d as the new winner // In the former case, the measure is valid - it used // d's new larger minSize. In the latter case, the // measure is invalid - it used the old shared size, // which is larger than d's (possibly changed) minSize measureIsValid = (definitionBase.LayoutWasUpdated && DoubleUtil.GreaterThanOrClose(definitionBase._minSize, this.MinSize)); } if (!measureIsValid) { Grid parentGrid = (Grid)definitionBase.Parent; parentGrid.InvalidateMeasure(); } else if (!DoubleUtil.AreClose(sharedMinSize, definitionBase.SizeCache)) { // if measure is valid then also need to check arrange. // Note: definitionBase.SizeCache is volatile but at this point // it contains up-to-date final size Grid parentGrid = (Grid)definitionBase.Parent; parentGrid.InvalidateArrange(); } // now we can restore the invariant, and clear the layout flag definitionBase.UseSharedMinimum = useSharedMinimum; definitionBase.LayoutWasUpdated = false; } _minSize = sharedMinSize; _layoutUpdatedHost.LayoutUpdated -= _layoutUpdated; _layoutUpdatedHost = null; _broadcastInvalidation = true; }