sdk/samples/WPFSamples/CompositionTargetRenderingAnimations/csharp/particleeffectexamples/overlayrenderdecorator.cs

   1 namespace Microsoft.Samples.PerFrameAnimations
   2 {
   3     using System;
   4     using System.Collections;
   5     using System.Collections.Generic;
   6     using System.ComponentModel;
   7     using System.Diagnostics;
   8     using System.Windows.Threading;
   9     using System.Windows.Media;
  10     using System.Windows.Markup;
  11     using System.Windows;
  12     using System.Windows.Controls;
  13
  14     /// <summary>
  15     /// This class is used internally to delegate it's rendering to the parent OverlayRenderDecorator.
  16     /// </summary>
  17     internal class OverlayRenderDecoratorOverlayVisual : DrawingVisual
  18     {
  19         private bool _hitTestVisible = false;
  20
  21         internal bool IsHitTestVisible
  22         {
  23             get
  24             {
  25                 return _hitTestVisible;
  26             }
  27             set
  28             {
  29                 _hitTestVisible = value;
  30             }
  31         }
  32
  33         //dont hit test, these are just overlay graphics
  34         protected override GeometryHitTestResult HitTestCore(GeometryHitTestParameters hitTestParameters)
  35         {
  36             if (IsHitTestVisible)
  37                 return base.HitTestCore(hitTestParameters);
  38             else
  39                 return null;
  40         }
  41
  42         //dont hit test, these are just overlay graphics
  43         protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters)
  44         {
  45             if (IsHitTestVisible)
  46                 return base.HitTestCore(hitTestParameters);
  47             else
  48                 return null;
  49         }
  50     }
  51
  52
  53
  54     /// <summary>
  55     /// OverlayRenderDecorator provides a simple overlay graphics mechanism similar
  56     /// to OnRender called OnOverlayRender
  57     /// </summary>
  58     [ContentProperty("Child")]
  59     public class OverlayRenderDecorator : FrameworkElement
  60     {
  61         //the only logical child
  62         private UIElement _child;
  63         private VisualCollection _vc;
  64
  65         //this will be a visual child, but not a logical child.  as the last child, it can 'overlay' graphics
  66         // by calling back to us with OnOverlayRender
  67         private OverlayRenderDecoratorOverlayVisual _overlayVisual;
  68
  69
  70         //-------------------------------------------------------------------
  71         //
  72         //  Constructors
  73         //
  74         //-------------------------------------------------------------------
  75
  76         #region Constructors
  77
  78         /// <summary>
  79         ///     Default constructor
  80         /// </summary>
  81         public OverlayRenderDecorator()
  82             : base()
  83         {
  84             _overlayVisual = new OverlayRenderDecoratorOverlayVisual();
  85
  86             _vc = new VisualCollection(this);
  87
  88             //insert the overlay element into the visual tree
  89             _vc.Add(_overlayVisual);
  90         }
  91
  92         #endregion
  93
  94
  95         //-------------------------------------------------------------------
  96         //
  97         //  Public Properties
  98         //
  99         //-------------------------------------------------------------------
 100
 101         #region Public Properties
 102
 103         /// <summary>
 104         /// Enables/Disables hit testing on the overlay visual
 105         /// </summary>
 106         public bool IsOverlayHitTestVisible
 107         {
 108             get
 109             {
 110                 if (_overlayVisual != null)
 111                     return _overlayVisual.IsHitTestVisible;
 112                 else
 113                     return false;
 114             }
 115             set
 116             {
 117                 if (_overlayVisual != null)
 118                     _overlayVisual.IsHitTestVisible = value;
 119             }
 120         }
 121
 122         /// <summary>
 123         /// The single child of an <see cref="System.Windows.Media.Animation.OverlayRenderDecorator" />
 124         /// </summary>
 125         [DefaultValue(null)]
 126         public virtual UIElement Child
 127         {
 128             get
 129             {
 130                 return _child;
 131             }
 132             set
 133             {
 134                 if (_child != value)
 135                 {
 136                     //need to remove old element from logical tree
 137                     if (_child != null)
 138                     {
 139                         OnDetachChild(_child);
 140                         RemoveLogicalChild(_child);
 141                     }
 142
 143                     _vc.Clear();
 144
 145                     if (value != null)
 146                     {
 147                         //add to visual
 148                         _vc.Add(value);
 149                         //add to logical
 150                         AddLogicalChild(value);
 151                     }
 152
 153                     //always add the overlay child back into the visual tree if its set
 154                     if (_overlayVisual != null)
 155                         _vc.Add(_overlayVisual);
 156
 157                     //cache the new child
 158                     _child = value;
 159
 160                     //notify derived types of the new child
 161                     if (value != null)
 162                         OnAttachChild(_child);
 163
 164                     InvalidateMeasure();
 165                 }
 166             }
 167         }
 168
 169         /// <summary>
 170         /// Returns enumerator to logical children.
 171         /// </summary>
 172         protected override IEnumerator LogicalChildren
 173         {
 174             get
 175             {
 176                 if (_child == null)
 177                 {
 178                     return (IEnumerator)new List<UIElement>().GetEnumerator();
 179                 }
 180                 List<UIElement> l = new List<UIElement>();
 181                 l.Add(_child);
 182                 return (IEnumerator)l.GetEnumerator();
 183             }
 184         }
 185
 186
 187         #endregion
 188
 189         //-------------------------------------------------------------------
 190         //
 191         //  Protected Methods
 192         //
 193         //-------------------------------------------------------------------
 194
 195         #region Protected Methods
 196
 197         /// <summary>
 198         /// Updates DesiredSize of the OverlayRenderDecorator.  Called by parent UIElement.  This is the first pass of layout.
 199         /// </summary>
 200         /// <remarks>
 201         /// OverlayRenderDecorator determines a desired size it needs from the child's sizing properties, margin, and requested size.
 202         /// </remarks>
 203         /// <param name="constraint">Constraint size is an "upper limit" that the return value should not exceed.</param>
 204         /// <returns>The OverlayRenderDecorator's desired size.</returns>
 205         protected override System.Windows.Size MeasureOverride(System.Windows.Size constraint)
 206         {
 207             UIElement child = Child;
 208             if (child != null)
 209             {
 210                 child.Measure(constraint);
 211                 return (child.DesiredSize);
 212             }
 213             return (new System.Windows.Size());
 214         }
 215
 216         /// <summary>
 217         /// OverlayRenderDecorator computes the position of its single child inside child's Margin and calls Arrange
 218         /// on the child.
 219         /// </summary>
 220         /// <param name="arrangeSize">Size the OverlayRenderDecorator will assume.</param>
 221         protected override System.Windows.Size ArrangeOverride(System.Windows.Size arrangeSize)
 222         {
 223             UIElement child = Child;
 224             if (child != null)
 225             {
 226                 child.Arrange(new Rect(arrangeSize));
 227             }
 228
 229             //Our OnRender gets called in Arrange, but
 230             //  we dont have access to that, so update the
 231             //  overlay here.
 232             if (_overlayVisual != null)
 233             {
 234                 using (DrawingContext dc = _overlayVisual.RenderOpen())
 235                 {
 236                     //delegate to derived types
 237                     OnOverlayRender(dc);
 238                 }
 239             }
 240
 241             return (arrangeSize);
 242         }
 243
 244         /// <summary>
 245         /// render method for overlay graphics.
 246         /// </summary>
 247         /// <param name="dc"></param>
 248         protected virtual void OnOverlayRender(DrawingContext dc)
 249         {
 250
 251         }
 252
 253         /// <summary>
 254         /// gives derives types a simple way to respond to a new child being added
 255         /// </summary>
 256         /// <param name="child"></param>
 257         protected virtual void OnAttachChild(UIElement child)
 258         {
 259
 260         }
 261
 262         /// <summary>
 263         /// gives derives types a simple way to respond to a child being removed
 264         /// </summary>
 265         /// <param name="child"></param>
 266         protected virtual void OnDetachChild(UIElement child)
 267         {
 268
 269         }
 270
 271         protected override int VisualChildrenCount
 272         {
 273             get {return _vc.Count;}
 274         }
 275
 276         protected override Visual GetVisualChild(int index)
 277         {
 278             return _vc[index];
 279         }
 280
 281         #endregion
 282
 283
 284     }
 285
 286 }