/// <summary> /// RevealModeProperty property changed handler. /// </summary> /// <param name="d">ExpandableContentControl that changed its RevealMode.</param> /// <param name="e">Event arguments.</param> private static void OnRevealModePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ExpandableContentControl source = (ExpandableContentControl)d; ExpandDirection value = (ExpandDirection)e.NewValue; if (value != ExpandDirection.Down && value != ExpandDirection.Left && value != ExpandDirection.Right && value != ExpandDirection.Up) { // revert to old value source.RevealMode = (ExpandDirection)e.OldValue; string message = string.Format( CultureInfo.InvariantCulture, "Expander_OnExpandDirectionPropertyChanged_InvalidValue", value); throw new ArgumentException(message, "e"); } // set the non-reveal dimension source.SetNonRevealDimension(); // calculate the reveal dimension source.SetRevealDimension(); }
/// <summary> /// Coerce the percentage property as necessary. /// </summary> /// <param name="d"></param> /// <param name="baseValue"></param> /// <returns></returns> private static object CoercePercentageProperty(DependencyObject d, object baseValue) { // This works around a subtle difference between WPF 3 and SL 3, // where a value assigned to a dependency property from within the control // is considered to be from a local source, and trumps styles/templates from that point forward. // This could be worked around in WPF 4.0 with DependencyObject.SetCurrentValue() object returnValue = baseValue; ExpandableContentControl expandableContentControl = d as ExpandableContentControl; // This method can be called by a parent control through RecalculatePercentage(double) // To know when to coerce and avoid having to do so more than needed, calculatePercentage can have 3 states: // Null: Don't corce using internal value, simply return baseValue // Double.NAN: Coerce by computing new percentage value based on current target size // value: Corece by returning explicit value previously set in RecalculatePercentage(double) if (expandableContentControl != null && expandableContentControl.calculatePercentage.HasValue) { if (double.IsNaN(expandableContentControl.calculatePercentage.Value)) { returnValue = CalculatePercentage(expandableContentControl, expandableContentControl.TargetSize); } else { returnValue = expandableContentControl.calculatePercentage.Value; } expandableContentControl.calculatePercentage = null; } return(returnValue); }
/// <summary> /// TargetSizeProperty property changed handler. /// </summary> /// <param name="d">ExpandableContentControl that changed its TargetSize.</param> /// <param name="e">Event arguments.</param> private static void OnTargetSizePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ExpandableContentControl source = (ExpandableContentControl)d; Size value = (Size)e.NewValue; // recalculate percentage based on this new targetsize. // for instance, percentage was at 1 and width was 100. Now width was changed to 200, this means // that the percentage needs to be set to 0.5 so that a reveal animation can be started again. source.RecalculatePercentage(value); }
/// <summary> /// TargetSizeProperty property changed handler. /// </summary> /// <param name="d">ExpandableContentControl that changed its TargetSize.</param> /// <param name="e">Event arguments.</param> private static void OnTargetSizePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ExpandableContentControl source = (ExpandableContentControl)d; Size value = (Size)e.NewValue; // recalculate percentage based on this new targetsize. // for instance, percentage was at 1 and width was 100. Now width was changed to 200, this means // that the percentage needs to be set to 0.5 so that a reveal animation can be started again. #if SILVERLIGHT source.RecalculatePercentage(value); #else // We are essentially trying to re-evaluate the percentage property based on another property having changed, // which is exactly what the coerce functionality of dependency properties is for source.RecalculatePercentage(double.NaN); #endif }
/// <summary> /// Recalculates the percentage based on a new size. /// </summary> /// <param name="expandableContentControl">The control which is going to be evaluated</param> /// <param name="value">The new size used to base percentages on.</param> /// <returns>The new percentage value</returns> private static double CalculatePercentage(ExpandableContentControl expandableContentControl, Size value) { double newPercentage = 0.0; if (expandableContentControl.ContentSite != null) { if (expandableContentControl.IsVerticalRevealMode) { newPercentage = expandableContentControl.ActualHeight / (double.IsNaN(value.Height) ? expandableContentControl.ContentSite.DesiredSize.Height : value.Height); } else if (expandableContentControl.IsHorizontalRevealMode) { newPercentage = expandableContentControl.ActualWidth / (double.IsNaN(value.Width) ? expandableContentControl.ContentSite.DesiredSize.Width : value.Width); } } return(newPercentage); }
/// <summary> /// PercentageProperty property changed handler. /// </summary> /// <param name="d">Page that changed its Percentage.</param> /// <param name="e">Event arguments.</param> private static void OnPercentagePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ExpandableContentControl source = (ExpandableContentControl)d; source.SetRevealDimension(); }
public virtual void ShouldAllowNoTemplateParts() { ExpandableContentControl ecc = new ExpandableContentControl(); ecc.Template = new ControlTemplate(); // touch all the public api. ecc.TargetSize = new Size(4, 4); ecc.RevealMode = ExpandDirection.Left; ecc.Percentage = 0.5; // show on screen TestAsync(ecc); }
public virtual void ShouldAllowStylingTargetStyle() { Style s = new Style(typeof(ExpandableContentControl)); s.Setters.Add(new Setter(ExpandableContentControl.TargetSizeProperty, new Size(400, 300))); ExpandableContentControl ecc = new ExpandableContentControl(); ecc.Style = s; }