├── .gitignore
├── Common
    ├── Borders
    │   ├── ClippingBorder.cs
    │   ├── InnerGlowBorder.cs
    │   └── OuterGlowBorder.cs
    ├── DropShadowTextBlock.cs
    ├── HorizontalToggleSwitch.cs
    ├── Icons
    │   ├── ToggleSwitch.HorizontalToggleSwitch.Expression.Large.png
    │   ├── ToggleSwitch.HorizontalToggleSwitch.Expression.Small.png
    │   └── ToggleSwitch.HorizontalToggleSwitch.VisualStudio.bmp
    ├── ToggleSwitchBase.cs
    ├── Utils
    │   ├── ActualSizePropertyProxy.cs
    │   ├── CornerRadiusValueConverter.cs
    │   ├── HelperExtensions.cs
    │   └── ScalarValueConverter.cs
    └── VerticalToggleSwitch.cs
├── README.md
├── WPF
    ├── Demo
    │   ├── App.xaml
    │   ├── App.xaml.cs
    │   ├── Assets
    │   │   ├── Brushes.xaml
    │   │   ├── Fonts.xaml
    │   │   ├── Styles.xaml
    │   │   └── ToggleSwitchStyles.xaml
    │   ├── Demo.csproj
    │   ├── DemoViewModel.cs
    │   ├── Images
    │   │   ├── Knob.png
    │   │   ├── lightOff.png
    │   │   └── lightOn.png
    │   ├── MainWindow.xaml
    │   ├── MainWindow.xaml.cs
    │   ├── Properties
    │   │   ├── AssemblyInfo.cs
    │   │   ├── Resources.Designer.cs
    │   │   ├── Resources.resx
    │   │   ├── Settings.Designer.cs
    │   │   └── Settings.settings
    │   ├── Views
    │   │   ├── Basics.xaml
    │   │   ├── Basics.xaml.cs
    │   │   ├── Events.xaml
    │   │   ├── Events.xaml.cs
    │   │   ├── Extending.xaml
    │   │   ├── Extending.xaml.cs
    │   │   ├── Styling.xaml
    │   │   └── Styling.xaml.cs
    │   └── app.config
    ├── ToggleSwitch.sln
    └── ToggleSwitch
    │   ├── Properties
    │       └── AssemblyInfo.cs
    │   ├── Themes
    │       └── Generic.xaml
    │   ├── ToggleSwitch.csproj
    │   └── ToggleSwitchKey.snk
└── icon.png


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Build Folders (you can keep bin if you'd like, to store dlls and pdbs)
 2 | bin
 3 | obj
 4 | 
 5 | # mstest test results
 6 | TestResults
 7 | 
 8 | # user files
 9 | *.user
10 | *.suo
11 | *ReSharper.*


--------------------------------------------------------------------------------
/Common/Borders/ClippingBorder.cs:
--------------------------------------------------------------------------------
  1 | //-----------------------------------------------------------------------
  2 | // <copyright file="ClippingBorder.cs" company="Microsoft Corporation copyright 2008.">
  3 | // (c) 2008 Microsoft Corporation. All rights reserved.
  4 | // This source is subject to the Microsoft Public License.
  5 | // See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
  6 | // </copyright>
  7 | // <date>07-Oct-2008</date>
  8 | // <author>Martin Grayson</author>
  9 | // <summary>A border that clips its contents.</summary>
 10 | //-----------------------------------------------------------------------
 11 | using System;
 12 | using System.ComponentModel;
 13 | using System.Windows;
 14 | using System.Windows.Controls;
 15 | using System.Windows.Media;
 16 | 
 17 | namespace ToggleSwitch.Borders
 18 | {
 19 |     /// <summary>
 20 |     /// A border that clips its contents.
 21 |     /// </summary>
 22 |     public class ClippingBorder : ContentControl
 23 |     {
 24 |         /// <summary>
 25 |         /// The corner radius property.
 26 |         /// </summary>
 27 |         public static readonly DependencyProperty CornerRadiusProperty = DependencyProperty.Register("CornerRadius", typeof(CornerRadius),
 28 |                                                                                                                                      typeof(ClippingBorder),
 29 |                                                                                                                                      new PropertyMetadata(CornerRadiusChanged));
 30 | 
 31 |         /// <summary>
 32 |         /// The clip content property.
 33 |         /// </summary>
 34 |         public static readonly DependencyProperty ClipContentProperty = DependencyProperty.Register("ClipContent", typeof(bool), typeof(ClippingBorder),
 35 |                                                                                                                                     new PropertyMetadata(ClipContentChanged));
 36 | 
 37 |         /// <summary>
 38 |         /// Stores the main border.
 39 |         /// </summary>
 40 |         private Border _border;
 41 | 
 42 |         /// <summary>
 43 |         /// Stores the clip responsible for clipping the bottom left corner.
 44 |         /// </summary>
 45 |         private RectangleGeometry _bottomLeftClip;
 46 | 
 47 |         /// <summary>
 48 |         /// Stores the bottom left content control.
 49 |         /// </summary>
 50 |         private ContentControl _bottomLeftContentControl;
 51 | 
 52 |         /// <summary>
 53 |         /// Stores the clip responsible for clipping the bottom right corner.
 54 |         /// </summary>
 55 |         private RectangleGeometry _bottomRightClip;
 56 | 
 57 |         /// <summary>
 58 |         /// Stores the bottom right content control.
 59 |         /// </summary>
 60 |         private ContentControl _bottomRightContentControl;
 61 | 
 62 |         /// <summary>
 63 |         /// Stores the clip responsible for clipping the top left corner.
 64 |         /// </summary>
 65 |         private RectangleGeometry _topLeftClip;
 66 | 
 67 |         /// <summary>
 68 |         /// Stores the top left content control.
 69 |         /// </summary>
 70 |         private ContentControl _topLeftContentControl;
 71 | 
 72 |         /// <summary>
 73 |         /// Stores the clip responsible for clipping the top right corner.
 74 |         /// </summary>
 75 |         private RectangleGeometry _topRightClip;
 76 | 
 77 |         /// <summary>
 78 |         /// Stores the top right content control.
 79 |         /// </summary>
 80 |         private ContentControl _topRightContentControl;
 81 | 
 82 |         /// <summary>
 83 |         /// ClippingBorder constructor.
 84 |         /// </summary>
 85 |         public ClippingBorder()
 86 |         {
 87 |             DefaultStyleKey = typeof(ClippingBorder);
 88 |             SizeChanged += ClippingBorderSizeChanged;
 89 |         }
 90 | 
 91 |         /// <summary>
 92 |         /// Gets or sets the border corner radius.
 93 |         /// This is a thickness, as there is a problem parsing CornerRadius types.
 94 |         /// </summary>
 95 |         [Category("Appearance"), Description("Sets the corner radius on the border.")]
 96 |         public CornerRadius CornerRadius
 97 |         {
 98 |             get
 99 |             {
100 |                 return (CornerRadius)GetValue(CornerRadiusProperty);
101 |             }
102 | 
103 |             set
104 |             {
105 |                 SetValue(CornerRadiusProperty, value);
106 |             }
107 |         }
108 | 
109 |         /// <summary>
110 |         /// Gets or sets a value indicating whether the content is clipped.
111 |         /// </summary>
112 |         [Category("Appearance"), Description("Sets whether the content is clipped or not.")]
113 |         public bool ClipContent
114 |         {
115 |             get
116 |             {
117 |                 return (bool)GetValue(ClipContentProperty);
118 |             }
119 |             set
120 |             {
121 |                 SetValue(ClipContentProperty, value);
122 |             }
123 |         }
124 | 
125 |         /// <summary>
126 |         /// Gets the UI elements out of the template.
127 |         /// </summary>
128 |         public override void OnApplyTemplate()
129 |         {
130 |             base.OnApplyTemplate();
131 | 
132 |             _border = GetTemplateChild("PART_Border") as Border;
133 |             _topLeftContentControl = GetTemplateChild("PART_TopLeftContentControl") as ContentControl;
134 |             _topRightContentControl = GetTemplateChild("PART_TopRightContentControl") as ContentControl;
135 |             _bottomRightContentControl = GetTemplateChild("PART_BottomRightContentControl") as ContentControl;
136 |             _bottomLeftContentControl = GetTemplateChild("PART_BottomLeftContentControl") as ContentControl;
137 | 
138 |             if (_topLeftContentControl != null)
139 |             {
140 |                 _topLeftContentControl.SizeChanged += ContentControlSizeChanged;
141 |             }
142 | 
143 |             _topLeftClip = GetTemplateChild("PART_TopLeftClip") as RectangleGeometry;
144 |             _topRightClip = GetTemplateChild("PART_TopRightClip") as RectangleGeometry;
145 |             _bottomRightClip = GetTemplateChild("PART_BottomRightClip") as RectangleGeometry;
146 |             _bottomLeftClip = GetTemplateChild("PART_BottomLeftClip") as RectangleGeometry;
147 | 
148 |             UpdateClipContent(ClipContent);
149 | 
150 |             UpdateCornerRadius(CornerRadius);
151 |         }
152 | 
153 |         /// <summary>
154 |         /// Sets the corner radius.
155 |         /// </summary>
156 |         /// <param name="newCornerRadius">The new corner radius.</param>
157 |         internal void UpdateCornerRadius(CornerRadius newCornerRadius)
158 |         {
159 |             if (_border != null)
160 |             {
161 |                 _border.CornerRadius = newCornerRadius;
162 |             }
163 | 
164 |             if (_topLeftClip != null)
165 |             {
166 |                 _topLeftClip.RadiusX = _topLeftClip.RadiusY = newCornerRadius.TopLeft - (Math.Min(BorderThickness.Left, BorderThickness.Top) / 2);
167 |             }
168 | 
169 |             if (_topRightClip != null)
170 |             {
171 |                 _topRightClip.RadiusX = _topRightClip.RadiusY = newCornerRadius.TopRight - (Math.Min(BorderThickness.Top, BorderThickness.Right) / 2);
172 |             }
173 | 
174 |             if (_bottomRightClip != null)
175 |             {
176 |                 _bottomRightClip.RadiusX = _bottomRightClip.RadiusY = newCornerRadius.BottomRight - (Math.Min(BorderThickness.Right, BorderThickness.Bottom) / 2);
177 |             }
178 | 
179 |             if (_bottomLeftClip != null)
180 |             {
181 |                 _bottomLeftClip.RadiusX = _bottomLeftClip.RadiusY = newCornerRadius.BottomLeft - (Math.Min(BorderThickness.Bottom, BorderThickness.Left) / 2);
182 |             }
183 | 
184 |             UpdateClipSize(new Size(ActualWidth, ActualHeight));
185 |         }
186 | 
187 |         /// <summary>
188 |         /// Updates whether the content is clipped.
189 |         /// </summary>
190 |         /// <param name="clipContent">Whether the content is clipped.</param>
191 |         internal void UpdateClipContent(bool clipContent)
192 |         {
193 |             if (clipContent)
194 |             {
195 |                 if (_topLeftContentControl != null)
196 |                 {
197 |                     _topLeftContentControl.Clip = _topLeftClip;
198 |                 }
199 | 
200 |                 if (_topRightContentControl != null)
201 |                 {
202 |                     _topRightContentControl.Clip = _topRightClip;
203 |                 }
204 | 
205 |                 if (_bottomRightContentControl != null)
206 |                 {
207 |                     _bottomRightContentControl.Clip = _bottomRightClip;
208 |                 }
209 | 
210 |                 if (_bottomLeftContentControl != null)
211 |                 {
212 |                     _bottomLeftContentControl.Clip = _bottomLeftClip;
213 |                 }
214 | 
215 |                 UpdateClipSize(new Size(ActualWidth, ActualHeight));
216 |             }
217 |             else
218 |             {
219 |                 if (_topLeftContentControl != null)
220 |                 {
221 |                     _topLeftContentControl.Clip = null;
222 |                 }
223 | 
224 |                 if (_topRightContentControl != null)
225 |                 {
226 |                     _topRightContentControl.Clip = null;
227 |                 }
228 | 
229 |                 if (_bottomRightContentControl != null)
230 |                 {
231 |                     _bottomRightContentControl.Clip = null;
232 |                 }
233 | 
234 |                 if (_bottomLeftContentControl != null)
235 |                 {
236 |                     _bottomLeftContentControl.Clip = null;
237 |                 }
238 |             }
239 |         }
240 | 
241 |         /// <summary>
242 |         /// Updates the corner radius.
243 |         /// </summary>
244 |         /// <param name="dependencyObject">The clipping border.</param>
245 |         /// <param name="eventArgs">Dependency Property Changed Event Args</param>
246 |         private static void CornerRadiusChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
247 |         {
248 |             var clippingBorder = (ClippingBorder)dependencyObject;
249 |             clippingBorder.UpdateCornerRadius((CornerRadius)eventArgs.NewValue);
250 |         }
251 | 
252 |         /// <summary>
253 |         /// Updates the content clipping.
254 |         /// </summary>
255 |         /// <param name="dependencyObject">The clipping border.</param>
256 |         /// <param name="eventArgs">Dependency Property Changed Event Args</param>
257 |         private static void ClipContentChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
258 |         {
259 |             var clippingBorder = (ClippingBorder)dependencyObject;
260 |             clippingBorder.UpdateClipContent((bool)eventArgs.NewValue);
261 |         }
262 | 
263 |         /// <summary>
264 |         /// Updates the clips.
265 |         /// </summary>
266 |         /// <param name="sender">The clipping border</param>
267 |         /// <param name="e">Size Changed Event Args.</param>
268 |         private void ClippingBorderSizeChanged(object sender, SizeChangedEventArgs e)
269 |         {
270 |             if (ClipContent)
271 |             {
272 |                 UpdateClipSize(e.NewSize);
273 |             }
274 |         }
275 | 
276 |         /// <summary>
277 |         /// Updates the clip size.
278 |         /// </summary>
279 |         /// <param name="sender">A content control.</param>
280 |         /// <param name="e">Size Changed Event Args</param>
281 |         private void ContentControlSizeChanged(object sender, SizeChangedEventArgs e)
282 |         {
283 |             if (ClipContent)
284 |             {
285 |                 UpdateClipSize(new Size(ActualWidth, ActualHeight));
286 |             }
287 |         }
288 | 
289 |         /// <summary>
290 |         /// Updates the clip size.
291 |         /// </summary>
292 |         /// <param name="size">The control size.</param>
293 |         private void UpdateClipSize(Size size)
294 |         {
295 |             if (size.Width > 0 || size.Height > 0)
296 |             {
297 |                 double contentWidth = Math.Max(0, size.Width - BorderThickness.Left - BorderThickness.Right);
298 |                 double contentHeight = Math.Max(0, size.Height - BorderThickness.Top - BorderThickness.Bottom);
299 | 
300 |                 if (_topLeftClip != null)
301 |                 {
302 |                     _topLeftClip.Rect = new Rect(0, 0, contentWidth + (CornerRadius.TopLeft * 2), contentHeight + (CornerRadius.TopLeft * 2));
303 |                 }
304 | 
305 |                 if (_topRightClip != null)
306 |                 {
307 |                     _topRightClip.Rect = new Rect(0 - CornerRadius.TopRight, 0, contentWidth + CornerRadius.TopRight, contentHeight + CornerRadius.TopRight);
308 |                 }
309 | 
310 |                 if (_bottomRightClip != null)
311 |                 {
312 |                     _bottomRightClip.Rect = new Rect(0 - CornerRadius.BottomRight, 0 - CornerRadius.BottomRight, contentWidth + CornerRadius.BottomRight,
313 |                                                                 contentHeight + CornerRadius.BottomRight);
314 |                 }
315 | 
316 |                 if (_bottomLeftClip != null)
317 |                 {
318 |                     _bottomLeftClip.Rect = new Rect(0, 0 - CornerRadius.BottomLeft, contentWidth + CornerRadius.BottomLeft, contentHeight + CornerRadius.BottomLeft);
319 |                 }
320 |             }
321 |         }
322 |     }
323 | }


--------------------------------------------------------------------------------
/Common/Borders/InnerGlowBorder.cs:
--------------------------------------------------------------------------------
  1 | //-----------------------------------------------------------------------
  2 | // <copyright file="InnerGlowBorder.cs" company="Microsoft Corporation copyright 2008.">
  3 | // (c) 2008 Microsoft Corporation. All rights reserved.
  4 | // This source is subject to the Microsoft Public License.
  5 | // See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
  6 | // </copyright>
  7 | // <date>03-Oct-2008</date>
  8 | // <author>Martin Grayson</author>
  9 | // <summary>A border that also shows an inner glow.</summary>
 10 | //-----------------------------------------------------------------------
 11 | using System;
 12 | using System.ComponentModel;
 13 | using System.Windows;
 14 | using System.Windows.Controls;
 15 | using System.Windows.Media;
 16 | 
 17 | namespace ToggleSwitch.Borders
 18 | {
 19 |     /// <summary>
 20 |     /// Content control that draws a glow around its inside.
 21 |     /// </summary>
 22 |     public class InnerGlowBorder : ContentControl
 23 |     {
 24 |         /// <summary>
 25 |         /// The inner glow opacity property.
 26 |         /// </summary>
 27 |         public static readonly DependencyProperty InnerGlowOpacityProperty = DependencyProperty.Register("InnerGlowOpacity", typeof(double),
 28 |                                                                                                                                           typeof(InnerGlowBorder), null);
 29 | 
 30 |         /// <summary>
 31 |         /// The inner glow size property.
 32 |         /// </summary>
 33 |         public static readonly DependencyProperty InnerGlowSizeProperty = DependencyProperty.Register("InnerGlowSize", typeof(Thickness),
 34 |                                                                                                                                       typeof(InnerGlowBorder),
 35 |                                                                                                                                       new PropertyMetadata(InnerGlowSizeChanged));
 36 | 
 37 |         /// <summary>
 38 |         /// The corner radius property.
 39 |         /// </summary>
 40 |         public static readonly DependencyProperty CornerRadiusProperty = DependencyProperty.Register("CornerRadius", typeof(CornerRadius),
 41 |                                                                                                                                      typeof(InnerGlowBorder), null);
 42 | 
 43 |         /// <summary>
 44 |         /// The inner glow color.
 45 |         /// </summary>
 46 |         public static readonly DependencyProperty InnerGlowColorProperty = DependencyProperty.Register("InnerGlowColor", typeof(Color),
 47 |                                                                                                                                         typeof(InnerGlowBorder),
 48 |                                                                                                                                         new PropertyMetadata(
 49 |                                                                                                                                             Colors.Black,
 50 |                                                                                                                                             InnerGlowColorChanged));
 51 | 
 52 |         /// <summary>
 53 |         /// The clip content property.
 54 |         /// </summary>
 55 |         public static readonly DependencyProperty ClipContentProperty = DependencyProperty.Register("ClipContent", typeof(bool), typeof(InnerGlowBorder), null);
 56 | 
 57 |         /// <summary>
 58 |         /// The content z-index property.
 59 |         /// </summary>
 60 |         public static readonly DependencyProperty ContentZIndexProperty = DependencyProperty.Register("ContentZIndex", typeof(int), typeof(InnerGlowBorder), null);
 61 | 
 62 |         /// <summary>
 63 |         /// Stores the bottom glow border.
 64 |         /// </summary>
 65 |         private Border _bottomGlow;
 66 | 
 67 |         /// <summary>
 68 |         /// Stores the bottom glow stop 0;
 69 |         /// </summary>
 70 |         private GradientStop _bottomGlowStop0;
 71 | 
 72 |         /// <summary>
 73 |         /// Stores the bottom glow stop 1.
 74 |         /// </summary>
 75 |         private GradientStop _bottomGlowStop1;
 76 | 
 77 |         /// <summary>
 78 |         /// Stores the left glow border.
 79 |         /// </summary>
 80 |         private Border _leftGlow;
 81 | 
 82 |         /// <summary>
 83 |         /// Stores the left glow stop 0;
 84 |         /// </summary>
 85 |         private GradientStop _leftGlowStop0;
 86 | 
 87 |         /// <summary>
 88 |         /// Stores the left glow stop 1;
 89 |         /// </summary>
 90 |         private GradientStop _leftGlowStop1;
 91 | 
 92 |         /// <summary>
 93 |         /// Stores the right glow border.
 94 |         /// </summary>
 95 |         private Border _rightGlow;
 96 | 
 97 |         /// <summary>
 98 |         /// Stores the right glow stop 0;
 99 |         /// </summary>
100 |         private GradientStop _rightGlowStop0;
101 | 
102 |         /// <summary>
103 |         /// Stores the right glow stop 1.
104 |         /// </summary>
105 |         private GradientStop _rightGlowStop1;
106 | 
107 |         /// <summary>
108 |         /// Stores the top glow border.
109 |         /// </summary>
110 |         private Border _topGlow;
111 | 
112 |         /// <summary>
113 |         /// Stores the top glow stop 0;
114 |         /// </summary>
115 |         private GradientStop _topGlowStop0;
116 | 
117 |         /// <summary>
118 |         /// Stores the top glow stop 1;
119 |         /// </summary>
120 |         private GradientStop _topGlowStop1;
121 | 
122 |         /// <summary>
123 |         /// InnerGlowBorder constructor.
124 |         /// </summary>
125 |         public InnerGlowBorder()
126 |         {
127 |             DefaultStyleKey = typeof(InnerGlowBorder);
128 |         }
129 | 
130 |         /// <summary>
131 |         /// Gets or sets a value indicating whether the content is clipped.
132 |         /// </summary>
133 |         [Category("Appearance"), Description("Sets whether the content is clipped or not.")]
134 |         public bool ClipContent
135 |         {
136 |             get
137 |             {
138 |                 return (bool)GetValue(ClipContentProperty);
139 |             }
140 |             set
141 |             {
142 |                 SetValue(ClipContentProperty, value);
143 |             }
144 |         }
145 | 
146 |         /// <summary>
147 |         /// Gets or sets the content z-index. 0 for behind shadow, 1 for in-front.
148 |         /// </summary>
149 |         [Category("Appearance"), Description("Set 0 for behind the shadow, 1 for in front.")]
150 |         public int ContentZIndex
151 |         {
152 |             get
153 |             {
154 |                 return (int)GetValue(ContentZIndexProperty);
155 |             }
156 |             set
157 |             {
158 |                 SetValue(ContentZIndexProperty, value);
159 |             }
160 |         }
161 | 
162 |         /// <summary>
163 |         /// Gets or sets the inner glow opacity.
164 |         /// </summary>
165 |         [Category("Appearance"), Description("The inner glow opacity.")]
166 |         public double InnerGlowOpacity
167 |         {
168 |             get
169 |             {
170 |                 return (double)GetValue(InnerGlowOpacityProperty);
171 |             }
172 |             set
173 |             {
174 |                 SetValue(InnerGlowOpacityProperty, value);
175 |             }
176 |         }
177 | 
178 |         /// <summary>
179 |         /// Gets or sets the inner glow color.
180 |         /// </summary>
181 |         [Category("Appearance"), Description("The inner glow color.")]
182 |         public Color InnerGlowColor
183 |         {
184 |             get
185 |             {
186 |                 return (Color)GetValue(InnerGlowColorProperty);
187 |             }
188 | 
189 |             set
190 |             {
191 |                 SetValue(InnerGlowColorProperty, value);
192 |             }
193 |         }
194 | 
195 |         /// <summary>
196 |         /// Gets or sets the inner glow size.
197 |         /// </summary>
198 |         [Category("Appearance"), Description("The inner glow size.")]
199 |         public Thickness InnerGlowSize
200 |         {
201 |             get
202 |             {
203 |                 return (Thickness)GetValue(InnerGlowSizeProperty);
204 |             }
205 | 
206 |             set
207 |             {
208 |                 SetValue(InnerGlowSizeProperty, value);
209 |                 UpdateGlowSize(value);
210 |             }
211 |         }
212 | 
213 |         /// <summary>
214 |         /// Gets or sets the border corner radius.
215 |         /// This is a thickness, as there is a problem parsing CornerRadius types.
216 |         /// </summary>
217 |         [Category("Appearance"), Description("Sets the corner radius on the border.")]
218 |         public CornerRadius CornerRadius
219 |         {
220 |             get
221 |             {
222 |                 return (CornerRadius)GetValue(CornerRadiusProperty);
223 |             }
224 | 
225 |             set
226 |             {
227 |                 SetValue(CornerRadiusProperty, value);
228 |             }
229 |         }
230 | 
231 |         /// <summary>
232 |         /// Gets the template parts out.
233 |         /// </summary>
234 |         public override void OnApplyTemplate()
235 |         {
236 |             base.OnApplyTemplate();
237 | 
238 |             _leftGlow = GetTemplateChild("PART_LeftGlow") as Border;
239 |             _topGlow = GetTemplateChild("PART_TopGlow") as Border;
240 |             _rightGlow = GetTemplateChild("PART_RightGlow") as Border;
241 |             _bottomGlow = GetTemplateChild("PART_BottomGlow") as Border;
242 | 
243 |             _leftGlowStop0 = GetTemplateChild("PART_LeftGlowStop0") as GradientStop;
244 |             _leftGlowStop1 = GetTemplateChild("PART_LeftGlowStop1") as GradientStop;
245 |             _topGlowStop0 = GetTemplateChild("PART_TopGlowStop0") as GradientStop;
246 |             _topGlowStop1 = GetTemplateChild("PART_TopGlowStop1") as GradientStop;
247 |             _rightGlowStop0 = GetTemplateChild("PART_RightGlowStop0") as GradientStop;
248 |             _rightGlowStop1 = GetTemplateChild("PART_RightGlowStop1") as GradientStop;
249 |             _bottomGlowStop0 = GetTemplateChild("PART_BottomGlowStop0") as GradientStop;
250 |             _bottomGlowStop1 = GetTemplateChild("PART_BottomGlowStop1") as GradientStop;
251 | 
252 |             UpdateGlowColor(InnerGlowColor);
253 |             UpdateGlowSize(InnerGlowSize);
254 |         }
255 | 
256 |         /// <summary>
257 |         /// Updates the inner glow color.
258 |         /// </summary>
259 |         /// <param name="color">The new color.</param>
260 |         internal void UpdateGlowColor(Color color)
261 |         {
262 |             if (_leftGlowStop0 != null)
263 |             {
264 |                 _leftGlowStop0.Color = color;
265 |             }
266 | 
267 |             if (_leftGlowStop1 != null)
268 |             {
269 |                 _leftGlowStop1.Color = Color.FromArgb(0, color.R, color.G, color.B);
270 |             }
271 | 
272 |             if (_topGlowStop0 != null)
273 |             {
274 |                 _topGlowStop0.Color = color;
275 |             }
276 | 
277 |             if (_topGlowStop1 != null)
278 |             {
279 |                 _topGlowStop1.Color = Color.FromArgb(0, color.R, color.G, color.B);
280 |             }
281 | 
282 |             if (_rightGlowStop0 != null)
283 |             {
284 |                 _rightGlowStop0.Color = color;
285 |             }
286 | 
287 |             if (_rightGlowStop1 != null)
288 |             {
289 |                 _rightGlowStop1.Color = Color.FromArgb(0, color.R, color.G, color.B);
290 |             }
291 | 
292 |             if (_bottomGlowStop0 != null)
293 |             {
294 |                 _bottomGlowStop0.Color = color;
295 |             }
296 | 
297 |             if (_bottomGlowStop1 != null)
298 |             {
299 |                 _bottomGlowStop1.Color = Color.FromArgb(0, color.R, color.G, color.B);
300 |             }
301 |         }
302 | 
303 |         /// <summary>
304 |         /// Sets the glow size.
305 |         /// </summary>
306 |         /// <param name="newGlowSize">The new glow size.</param>
307 |         internal void UpdateGlowSize(Thickness newGlowSize)
308 |         {
309 |             if (_leftGlow != null)
310 |             {
311 |                 _leftGlow.Width = Math.Abs(newGlowSize.Left);
312 |             }
313 | 
314 |             if (_topGlow != null)
315 |             {
316 |                 _topGlow.Height = Math.Abs(newGlowSize.Top);
317 |             }
318 | 
319 |             if (_rightGlow != null)
320 |             {
321 |                 _rightGlow.Width = Math.Abs(newGlowSize.Right);
322 |             }
323 | 
324 |             if (_bottomGlow != null)
325 |             {
326 |                 _bottomGlow.Height = Math.Abs(newGlowSize.Bottom);
327 |             }
328 |         }
329 | 
330 |         /// <summary>
331 |         /// Updates the inner glow color when the DP changes.
332 |         /// </summary>
333 |         /// <param name="dependencyObject">The inner glow border.</param>
334 |         /// <param name="eventArgs">The new property event args.</param>
335 |         private static void InnerGlowColorChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
336 |         {
337 |             if (eventArgs.NewValue != null)
338 |             {
339 |                 var innerGlowBorder = (InnerGlowBorder)dependencyObject;
340 |                 innerGlowBorder.UpdateGlowColor((Color)eventArgs.NewValue);
341 |             }
342 |         }
343 | 
344 |         /// <summary>
345 |         /// Updates the glow size.
346 |         /// </summary>
347 |         /// <param name="dependencyObject">The inner glow border.</param>
348 |         /// <param name="eventArgs">Dependency Property Changed Event Args</param>
349 |         private static void InnerGlowSizeChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
350 |         {
351 |             var innerGlowBorder = (InnerGlowBorder)dependencyObject;
352 |             innerGlowBorder.UpdateGlowSize((Thickness)eventArgs.NewValue);
353 |         }
354 |     }
355 | }


--------------------------------------------------------------------------------
/Common/Borders/OuterGlowBorder.cs:
--------------------------------------------------------------------------------
  1 | //-----------------------------------------------------------------------
  2 | // <copyright file="OuterGlowBorder.cs" company="Microsoft Corporation copyright 2008.">
  3 | // (c) 2008 Microsoft Corporation. All rights reserved.
  4 | // This source is subject to the Microsoft Public License.
  5 | // See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
  6 | // </copyright>
  7 | // <date>15-Sep-2008</date>
  8 | // <author>Martin Grayson</author>
  9 | // <summary>A border that also shows an outer glow.</summary>
 10 | //-----------------------------------------------------------------------
 11 | using System;
 12 | using System.ComponentModel;
 13 | using System.Windows;
 14 | using System.Windows.Controls;
 15 | using System.Windows.Media;
 16 | 
 17 | namespace ToggleSwitch.Borders
 18 | {
 19 |     /// <summary>
 20 |     /// Content control that draws and outer glow around itself.
 21 |     /// </summary>
 22 |     public class OuterGlowBorder : ContentControl
 23 |     {
 24 |         /// <summary>
 25 |         /// The outer glow opacity property.
 26 |         /// </summary>
 27 |         public static readonly DependencyProperty OuterGlowOpacityProperty = DependencyProperty.Register("OuterGlowOpacity", typeof(double),
 28 |                                                                                                                                           typeof(OuterGlowBorder), null);
 29 | 
 30 |         /// <summary>
 31 |         /// The outer glow size property.
 32 |         /// </summary>
 33 |         public static readonly DependencyProperty OuterGlowSizeProperty = DependencyProperty.Register("OuterGlowSize", typeof(double),
 34 |                                                                                                                                       typeof(OuterGlowBorder), null);
 35 | 
 36 |         /// <summary>
 37 |         /// The corner radius property.
 38 |         /// </summary>
 39 |         public static readonly DependencyProperty CornerRadiusProperty = DependencyProperty.Register("CornerRadius", typeof(CornerRadius),
 40 |                                                                                                                                      typeof(OuterGlowBorder), null);
 41 | 
 42 |         /// <summary>
 43 |         /// The shadow corner radius property.
 44 |         /// </summary>
 45 |         public static readonly DependencyProperty ShadowCornerRadiusProperty = DependencyProperty.Register("ShadowCornerRadius", typeof(CornerRadius),
 46 |                                                                                                                                              typeof(OuterGlowBorder), null);
 47 | 
 48 |         /// <summary>
 49 |         /// The outer glow color.
 50 |         /// </summary>
 51 |         public static readonly DependencyProperty OuterGlowColorProperty = DependencyProperty.Register("OuterGlowColor", typeof(Color),
 52 |                                                                                                                                         typeof(OuterGlowBorder),
 53 |                                                                                                                                         new PropertyMetadata(
 54 |                                                                                                                                             Colors.Black,
 55 |                                                                                                                                             OuterGlowColorChanged));
 56 | 
 57 |         /// <summary>
 58 |         /// The clip content property.
 59 |         /// </summary>
 60 |         public static readonly DependencyProperty ClipContentProperty = DependencyProperty.Register("ClipContent", typeof(bool), typeof(OuterGlowBorder),
 61 |                                                                                                                                     null);
 62 | 
 63 |         /// <summary>
 64 |         /// Stores the outer glow border.
 65 |         /// </summary>
 66 |         private Border _outerGlowBorder;
 67 | 
 68 |         /// <summary>
 69 |         /// Stores the left gradient stop.
 70 |         /// </summary>
 71 |         private GradientStop _shadowHorizontal1;
 72 | 
 73 |         /// <summary>
 74 |         /// Stores the right gradient stop.
 75 |         /// </summary>
 76 |         private GradientStop _shadowHorizontal2;
 77 | 
 78 |         /// <summary>
 79 |         /// The top out gradient stop.
 80 |         /// </summary>
 81 |         private GradientStop _shadowOuterStop1;
 82 | 
 83 |         /// <summary>
 84 |         /// The bottom outer gradient stop.
 85 |         /// </summary>
 86 |         private GradientStop _shadowOuterStop2;
 87 | 
 88 |         /// <summary>
 89 |         /// Stores the top gradient stop.
 90 |         /// </summary>
 91 |         private GradientStop _shadowVertical1;
 92 | 
 93 |         /// <summary>
 94 |         /// Stores the bottom gradient stop.
 95 |         /// </summary>
 96 |         private GradientStop _shadowVertical2;
 97 | 
 98 |         /// <summary>
 99 |         /// Out glow border constructor.
100 |         /// </summary>
101 |         public OuterGlowBorder()
102 |         {
103 |             DefaultStyleKey = typeof(OuterGlowBorder);
104 |             SizeChanged += OuterGlowContentControlSizeChanged;
105 |         }
106 | 
107 |         /// <summary>
108 |         /// Gets or sets a value indicating whether the content is clipped.
109 |         /// </summary>
110 |         [Category("Appearance"), Description("Sets whether the content is clipped or not.")]
111 |         public bool ClipContent
112 |         {
113 |             get
114 |             {
115 |                 return (bool)GetValue(ClipContentProperty);
116 |             }
117 |             set
118 |             {
119 |                 SetValue(ClipContentProperty, value);
120 |             }
121 |         }
122 | 
123 |         /// <summary>
124 |         /// Gets or sets the outer glow opacity.
125 |         /// </summary>
126 |         [Category("Appearance"), Description("The outer glow opacity.")]
127 |         public double OuterGlowOpacity
128 |         {
129 |             get
130 |             {
131 |                 return (double)GetValue(OuterGlowOpacityProperty);
132 |             }
133 |             set
134 |             {
135 |                 SetValue(OuterGlowOpacityProperty, value);
136 |             }
137 |         }
138 | 
139 |         /// <summary>
140 |         /// Gets or sets the outer glow size.
141 |         /// </summary>
142 |         [Category("Appearance"), Description("The outer glow size.")]
143 |         public double OuterGlowSize
144 |         {
145 |             get
146 |             {
147 |                 return (double)GetValue(OuterGlowSizeProperty);
148 |             }
149 | 
150 |             set
151 |             {
152 |                 SetValue(OuterGlowSizeProperty, value);
153 |                 UpdateGlowSize(OuterGlowSize);
154 |                 UpdateStops(new Size(ActualWidth, ActualHeight));
155 |             }
156 |         }
157 | 
158 |         /// <summary>
159 |         /// Gets or sets the outer glow color.
160 |         /// </summary>
161 |         [Category("Appearance"), Description("The outer glow color.")]
162 |         public Color OuterGlowColor
163 |         {
164 |             get
165 |             {
166 |                 return (Color)GetValue(OuterGlowColorProperty);
167 |             }
168 | 
169 |             set
170 |             {
171 |                 SetValue(OuterGlowColorProperty, value);
172 |             }
173 |         }
174 | 
175 |         /// <summary>
176 |         /// Gets or sets the border corner radius.
177 |         /// This is a thickness, as there is a problem parsing CornerRadius types.
178 |         /// </summary>
179 |         [Category("Appearance"), Description("Sets the corner radius on the border.")]
180 |         public CornerRadius CornerRadius
181 |         {
182 |             get
183 |             {
184 |                 return (CornerRadius)GetValue(CornerRadiusProperty);
185 |             }
186 | 
187 |             set
188 |             {
189 |                 SetValue(CornerRadiusProperty, value);
190 | 
191 |                 ShadowCornerRadius = new CornerRadius(Math.Abs(value.TopLeft * 1.5), Math.Abs(value.TopRight * 1.5), Math.Abs(value.BottomRight * 1.5),
192 |                                                                          Math.Abs(value.BottomLeft * 1.5));
193 |             }
194 |         }
195 | 
196 |         /// <summary>
197 |         /// Gets or sets the border corner radius.
198 |         /// This is a thickness, as there is a problem parsing CornerRadius types.
199 |         /// </summary>
200 |         [Category("Appearance"), Description("Sets the corner radius on the border.")]
201 |         public CornerRadius ShadowCornerRadius
202 |         {
203 |             get
204 |             {
205 |                 return (CornerRadius)GetValue(ShadowCornerRadiusProperty);
206 |             }
207 | 
208 |             set
209 |             {
210 |                 SetValue(ShadowCornerRadiusProperty, value);
211 |             }
212 |         }
213 | 
214 |         /// <summary>
215 |         /// Gets the parts out of the template.
216 |         /// </summary>
217 |         public override void OnApplyTemplate()
218 |         {
219 |             base.OnApplyTemplate();
220 |             _shadowOuterStop1 = (GradientStop)GetTemplateChild("PART_ShadowOuterStop1");
221 |             _shadowOuterStop2 = (GradientStop)GetTemplateChild("PART_ShadowOuterStop2");
222 |             _shadowVertical1 = (GradientStop)GetTemplateChild("PART_ShadowVertical1");
223 |             _shadowVertical2 = (GradientStop)GetTemplateChild("PART_ShadowVertical2");
224 |             _shadowHorizontal1 = (GradientStop)GetTemplateChild("PART_ShadowHorizontal1");
225 |             _shadowHorizontal2 = (GradientStop)GetTemplateChild("PART_ShadowHorizontal2");
226 |             _outerGlowBorder = (Border)GetTemplateChild("PART_OuterGlowBorder");
227 |             UpdateGlowSize(OuterGlowSize);
228 |             UpdateGlowColor(OuterGlowColor);
229 |         }
230 | 
231 |         /// <summary>
232 |         /// Updates the glow size.
233 |         /// </summary>
234 |         /// <param name="size">The new size.</param>
235 |         internal void UpdateGlowSize(double size)
236 |         {
237 |             if (_outerGlowBorder != null)
238 |             {
239 |                 _outerGlowBorder.Margin = new Thickness(-Math.Abs(size));
240 |             }
241 |         }
242 | 
243 |         /// <summary>
244 |         /// Updates the outer glow color.
245 |         /// </summary>
246 |         /// <param name="color">The new color.</param>
247 |         internal void UpdateGlowColor(Color color)
248 |         {
249 |             if (_shadowVertical1 != null)
250 |             {
251 |                 _shadowVertical1.Color = color;
252 |             }
253 | 
254 |             if (_shadowVertical2 != null)
255 |             {
256 |                 _shadowVertical2.Color = color;
257 |             }
258 | 
259 |             if (_shadowOuterStop1 != null)
260 |             {
261 |                 _shadowOuterStop1.Color = Color.FromArgb(0, color.R, color.G, color.B);
262 |             }
263 | 
264 |             if (_shadowOuterStop2 != null)
265 |             {
266 |                 _shadowOuterStop2.Color = Color.FromArgb(0, color.R, color.G, color.B);
267 |             }
268 |         }
269 | 
270 |         /// <summary>
271 |         /// Updates the outer glow color when the DP changes.
272 |         /// </summary>
273 |         /// <param name="dependencyObject">The outer glow border.</param>
274 |         /// <param name="eventArgs">The new property event args.</param>
275 |         private static void OuterGlowColorChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
276 |         {
277 |             if (eventArgs.NewValue != null)
278 |             {
279 |                 var outerGlowBorder = (OuterGlowBorder)dependencyObject;
280 |                 outerGlowBorder.UpdateGlowColor((Color)eventArgs.NewValue);
281 |             }
282 |         }
283 | 
284 |         /// <summary>
285 |         /// Updates the gradient stops on the drop shadow.
286 |         /// </summary>
287 |         /// <param name="sender">The outer glow border.</param>
288 |         /// <param name="e">Size changed event args.</param>
289 |         private void OuterGlowContentControlSizeChanged(object sender, SizeChangedEventArgs e)
290 |         {
291 |             UpdateStops(e.NewSize);
292 |         }
293 | 
294 |         /// <summary>
295 |         /// Updates the gradient stops.
296 |         /// </summary>
297 |         /// <param name="size">The size of the control.</param>
298 |         private void UpdateStops(Size size)
299 |         {
300 |             if (size.Width > 0 && size.Height > 0)
301 |             {
302 |                 if (_shadowHorizontal1 != null)
303 |                 {
304 |                     _shadowHorizontal1.Offset = Math.Abs(OuterGlowSize) / (size.Width + Math.Abs(OuterGlowSize) + Math.Abs(OuterGlowSize));
305 |                 }
306 | 
307 |                 if (_shadowHorizontal2 != null)
308 |                 {
309 |                     _shadowHorizontal2.Offset = 1 - (Math.Abs(OuterGlowSize) / (size.Width + Math.Abs(OuterGlowSize) + Math.Abs(OuterGlowSize)));
310 |                 }
311 | 
312 |                 if (_shadowVertical1 != null)
313 |                 {
314 |                     _shadowVertical1.Offset = Math.Abs(OuterGlowSize) / (size.Height + Math.Abs(OuterGlowSize) + Math.Abs(OuterGlowSize));
315 |                 }
316 | 
317 |                 if (_shadowVertical2 != null)
318 |                 {
319 |                     _shadowVertical2.Offset = 1 - (Math.Abs(OuterGlowSize) / (size.Height + Math.Abs(OuterGlowSize) + Math.Abs(OuterGlowSize)));
320 |                 }
321 |             }
322 |         }
323 |     }
324 | }


--------------------------------------------------------------------------------
/Common/DropShadowTextBlock.cs:
--------------------------------------------------------------------------------
  1 | //-----------------------------------------------------------------------
  2 | // <copyright file="DropShadowTextBlock.cs" company="Microsoft Corporation copyright 2008.">
  3 | // (c) 2008 Microsoft Corporation. All rights reserved.
  4 | // This source is subject to the Microsoft Public License.
  5 | // See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx.
  6 | // </copyright>
  7 | // <date>09-Oct-2008</date>
  8 | // <author>Martin Grayson</author>
  9 | // <summary>A control that displays text, with a drop shadow.</summary>
 10 | //-----------------------------------------------------------------------
 11 | using System;
 12 | using System.ComponentModel;
 13 | using System.Windows;
 14 | using System.Windows.Controls;
 15 | using System.Windows.Media;
 16 | 
 17 | namespace Demo.Controls
 18 | {
 19 |     /// <summary>
 20 |     /// A control that displays text, with a drop shadow.
 21 |     /// </summary>
 22 |     public class DropShadowTextBlock : Control
 23 |     {
 24 |         /// <summary>
 25 |         /// The drop shadow color property.
 26 |         /// </summary>
 27 |         public static readonly DependencyProperty DropShadowColorProperty = DependencyProperty.Register("DropShadowColor", typeof(Color), typeof(DropShadowTextBlock), new PropertyMetadata(DropShadowColorChanged));
 28 | 
 29 |         /// <summary>
 30 |         /// The drop shadow opacity property.
 31 |         /// </summary>
 32 |         public static readonly DependencyProperty DropShadowOpacityProperty = DependencyProperty.Register("DropShadowOpacity", typeof(double), typeof(DropShadowTextBlock), new PropertyMetadata(DropShadowOpacityChanged));
 33 | 
 34 |         /// <summary>
 35 |         /// The text property.
 36 |         /// </summary>
 37 |         public static readonly DependencyProperty TextProperty = DependencyProperty.Register("Text", typeof(string), typeof(DropShadowTextBlock), null);
 38 | 
 39 |         /// <summary>
 40 |         /// The text decorations property.
 41 |         /// </summary>
 42 |         public static readonly DependencyProperty TextDecorationsProperty = DependencyProperty.Register("TextDecorations", typeof(TextDecorationCollection), typeof(DropShadowTextBlock), null);
 43 | 
 44 |         /// <summary>
 45 |         /// The text wrapping property.
 46 |         /// </summary>
 47 |         public static readonly DependencyProperty TextWrappingProperty = DependencyProperty.Register("TextWrapping", typeof(TextWrapping), typeof(DropShadowTextBlock), null);
 48 | 
 49 |         /// <summary>
 50 |         /// The drop shadow distance property.
 51 |         /// </summary>
 52 |         public static readonly DependencyProperty DropShadowDistanceProperty = DependencyProperty.Register("DropShadowDistance", typeof(double), typeof(DropShadowTextBlock), new PropertyMetadata(DropShadowDistanceChanged));
 53 | 
 54 |         /// <summary>
 55 |         /// The drop shadow angle property.
 56 |         /// </summary>
 57 |         public static readonly DependencyProperty DropShadowAngleProperty = DependencyProperty.Register("DropShadowAngle", typeof(double), typeof(DropShadowTextBlock), new PropertyMetadata(DropShadowAngleChanged));
 58 | 
 59 |         /// <summary>
 60 |         /// Stores the drop shadow brush.
 61 |         /// </summary>
 62 |         private SolidColorBrush _dropShadowBrush;
 63 | 
 64 |         /// <summary>
 65 |         /// Stores the drop shadow translate transform.
 66 |         /// </summary>
 67 |         private TranslateTransform _dropShadowTranslate;
 68 | 
 69 |         /// <summary>
 70 |         /// DropShadowTextBlock constructor.
 71 |         /// </summary>
 72 |         public DropShadowTextBlock()
 73 |         {
 74 |             DefaultStyleKey = typeof(DropShadowTextBlock);
 75 |         }
 76 | 
 77 |         /// <summary>
 78 |         /// Gets or sets the drop shadow color.
 79 |         /// </summary>
 80 |         [Category("Appearance"), Description("The drop shadow color.")]
 81 |         public Color DropShadowColor
 82 |         {
 83 |             get
 84 |             {
 85 |                 return (Color)GetValue(DropShadowColorProperty);
 86 |             }
 87 |             set
 88 |             {
 89 |                 SetValue(DropShadowColorProperty, value);
 90 |             }
 91 |         }
 92 | 
 93 |         /// <summary>
 94 |         /// Gets or sets the drop shadow opacity.
 95 |         /// </summary>
 96 |         [Category("Appearance"), Description("The drop shadow opacity.")]
 97 |         public double DropShadowOpacity
 98 |         {
 99 |             get
100 |             {
101 |                 return (double)GetValue(DropShadowOpacityProperty);
102 |             }
103 |             set
104 |             {
105 |                 SetValue(DropShadowOpacityProperty, value);
106 |             }
107 |         }
108 | 
109 |         /// <summary>
110 |         /// Gets or sets the link text.
111 |         /// </summary>
112 |         [Category("Common Properties"), Description("The text content.")]
113 |         public string Text
114 |         {
115 |             get
116 |             {
117 |                 return (string)GetValue(TextProperty);
118 |             }
119 |             set
120 |             {
121 |                 SetValue(TextProperty, value);
122 |             }
123 |         }
124 | 
125 |         /// <summary>
126 |         /// Gets or sets the text decorations.
127 |         /// </summary>
128 |         [Category("Common Properties"), Description("The text decorations.")]
129 |         public TextDecorationCollection TextDecorations
130 |         {
131 |             get
132 |             {
133 |                 return (TextDecorationCollection)GetValue(TextDecorationsProperty);
134 |             }
135 |             set
136 |             {
137 |                 SetValue(TextDecorationsProperty, value);
138 |             }
139 |         }
140 | 
141 |         /// <summary>
142 |         /// Gets or sets the text wrapping.
143 |         /// </summary>
144 |         [Category("Common Properties"), Description("Whether the text wraps.")]
145 |         public TextWrapping TextWrapping
146 |         {
147 |             get
148 |             {
149 |                 return (TextWrapping)GetValue(TextWrappingProperty);
150 |             }
151 |             set
152 |             {
153 |                 SetValue(TextWrappingProperty, value);
154 |             }
155 |         }
156 | 
157 |         /// <summary>
158 |         /// Gets or sets the drop shadow distance.
159 |         /// </summary>
160 |         [Category("Appearance"), Description("The drop shadow distance.")]
161 |         public double DropShadowDistance
162 |         {
163 |             get
164 |             {
165 |                 return (double)GetValue(DropShadowDistanceProperty);
166 |             }
167 |             set
168 |             {
169 |                 SetValue(DropShadowDistanceProperty, value);
170 |             }
171 |         }
172 | 
173 |         /// <summary>
174 |         /// Gets or sets the drop shadow angle.
175 |         /// </summary>
176 |         [Category("Appearance"), Description("The drop shadow angle.")]
177 |         public double DropShadowAngle
178 |         {
179 |             get
180 |             {
181 |                 return (double)GetValue(DropShadowAngleProperty);
182 |             }
183 |             set
184 |             {
185 |                 SetValue(DropShadowAngleProperty, value);
186 |             }
187 |         }
188 | 
189 |         /// <summary>
190 |         /// Gets the UI elements out of the template.
191 |         /// </summary>
192 |         public override void OnApplyTemplate()
193 |         {
194 |             base.OnApplyTemplate();
195 |             _dropShadowTranslate = GetTemplateChild("PART_DropShadowTranslate") as TranslateTransform;
196 |             _dropShadowBrush = GetTemplateChild("PART_DropShadowBrush") as SolidColorBrush;
197 |             UpdateDropShadowPosition();
198 |             UpdateDropShadowBrush();
199 |         }
200 | 
201 |         /// <summary>
202 |         /// Converts degrees into radians.
203 |         /// </summary>
204 |         /// <param name="degrees">The degree value.</param>
205 |         /// <returns>The degrees as radians.</returns>
206 |         private static double DegreesToRadians(double degrees)
207 |         {
208 |             return degrees * (Math.PI / 180);
209 |         }
210 | 
211 |         /// <summary>
212 |         /// Gets a point offset by a distance and angle (in degrees).
213 |         /// </summary>
214 |         /// <param name="angle">The angle in degrees.</param>
215 |         /// <param name="distance">The distance.</param>
216 |         /// <returns>The offset point.</returns>
217 |         private static Point GetOffset(double angle, double distance)
218 |         {
219 |             double x = Math.Cos(DegreesToRadians(angle)) * distance;
220 |             double y = Math.Tan(DegreesToRadians(angle)) * x;
221 |             return new Point(x, y);
222 |         }
223 | 
224 |         /// <summary>
225 |         /// Updates the drop shadow.
226 |         /// </summary>
227 |         internal void UpdateDropShadowPosition()
228 |         {
229 |             if (_dropShadowTranslate != null)
230 |             {
231 |                 Point offset = GetOffset(DropShadowAngle, DropShadowDistance);
232 | 
233 |                 _dropShadowTranslate.X = offset.X;
234 |                 _dropShadowTranslate.Y = offset.Y;
235 |             }
236 |         }
237 | 
238 |         /// <summary>
239 |         /// Updates the drop shadow brush.
240 |         /// </summary>
241 |         internal void UpdateDropShadowBrush()
242 |         {
243 |             if (_dropShadowBrush != null)
244 |             {
245 |                 _dropShadowBrush.Color = DropShadowColor;
246 |                 _dropShadowBrush.Opacity = DropShadowOpacity;
247 |             }
248 |         }
249 | 
250 |         /// <summary>
251 |         /// Updates the drop shadow.
252 |         /// </summary>
253 |         /// <param name="dependencyObject">The drop shadow text block.</param>
254 |         /// <param name="eventArgs">Dependency Property Changed Event Args</param>
255 |         private static void DropShadowDistanceChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
256 |         {
257 |             var dropShadowTextBlock = (DropShadowTextBlock)dependencyObject;
258 |             dropShadowTextBlock.UpdateDropShadowPosition();
259 |         }
260 | 
261 |         /// <summary>
262 |         /// Updates the drop shadow.
263 |         /// </summary>
264 |         /// <param name="dependencyObject">The drop shadow text block.</param>
265 |         /// <param name="eventArgs">Dependency Property Changed Event Args</param>
266 |         private static void DropShadowAngleChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
267 |         {
268 |             var dropShadowTextBlock = (DropShadowTextBlock)dependencyObject;
269 |             dropShadowTextBlock.UpdateDropShadowPosition();
270 |         }
271 | 
272 |         /// <summary>
273 |         /// Updates the drop shadow.
274 |         /// </summary>
275 |         /// <param name="dependencyObject">The drop shadow text block.</param>
276 |         /// <param name="eventArgs">Dependency Property Changed Event Args</param>
277 |         private static void DropShadowColorChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
278 |         {
279 |             var dropShadowTextBlock = (DropShadowTextBlock)dependencyObject;
280 |             dropShadowTextBlock.UpdateDropShadowBrush();
281 |         }
282 | 
283 |         /// <summary>
284 |         /// Updates the drop shadow.
285 |         /// </summary>
286 |         /// <param name="dependencyObject">The drop shadow text block.</param>
287 |         /// <param name="eventArgs">Dependency Property Changed Event Args</param>
288 |         private static void DropShadowOpacityChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
289 |         {
290 |             var dropShadowTextBlock = (DropShadowTextBlock)dependencyObject;
291 |             dropShadowTextBlock.UpdateDropShadowBrush();
292 |         }
293 |     }
294 | }


--------------------------------------------------------------------------------
/Common/HorizontalToggleSwitch.cs:
--------------------------------------------------------------------------------
  1 | //-----------------------------------------------------------------------
  2 | // <copyright file="HorizontalToggleSwitch.cs">
  3 | // (c) 2011 Eric Jensen. All rights reserved.
  4 | // This source is subject to the Microsoft Public License.
  5 | // See http://www.opensource.org/licenses/MS-PL.
  6 | // </copyright>
  7 | // <date>15-Sept-2011</date>
  8 | // <author>Eric Jensen</author>
  9 | // <summary>Horizontally oriented toggle switch control.</summary>
 10 | //-----------------------------------------------------------------------
 11 | using System;
 12 | using System.Windows;
 13 | using System.Windows.Controls;
 14 | using System.Windows.Controls.Primitives;
 15 | 
 16 | namespace ToggleSwitch
 17 | {
 18 |     ///<summary>
 19 |     /// Horizontally oriented toggle switch control.
 20 |     ///</summary>
 21 |     public class HorizontalToggleSwitch : ToggleSwitchBase
 22 |     {
 23 |         public HorizontalToggleSwitch()
 24 |         {
 25 |             DefaultStyleKey = typeof(HorizontalToggleSwitch);
 26 |         }
 27 | 
 28 |         protected override double Offset
 29 |         {
 30 |             get { return Canvas.GetLeft(SwitchThumb); }
 31 |             set
 32 |             {
 33 |                 SwitchTrack.BeginAnimation(Canvas.LeftProperty, null);
 34 |                 SwitchThumb.BeginAnimation(Canvas.LeftProperty, null);
 35 |                 Canvas.SetLeft(SwitchTrack, value);
 36 |                 Canvas.SetLeft(SwitchThumb, value);
 37 |             }
 38 |         }
 39 | 
 40 |         protected override PropertyPath SlidePropertyPath
 41 |         {
 42 |             get { return new PropertyPath("(Canvas.Left)"); }
 43 |         }
 44 | 
 45 |         protected override void OnDragDelta(object sender, DragDeltaEventArgs e)
 46 |         {
 47 |             DragOffset += e.HorizontalChange;
 48 |             Offset = Math.Max(UncheckedOffset, Math.Min(CheckedOffset, DragOffset));
 49 |         }
 50 | 
 51 |         protected override void LayoutControls()
 52 |         {
 53 |             if (SwitchThumb == null || SwitchRoot == null)
 54 |             {
 55 |                 return;
 56 |             }
 57 | 
 58 |             double fullThumbWidth = SwitchThumb.ActualWidth + SwitchThumb.BorderThickness.Left + SwitchThumb.BorderThickness.Right;
 59 | 
 60 |             if (SwitchChecked != null && SwitchUnchecked != null)
 61 |             {
 62 |                 SwitchChecked.Width = SwitchUnchecked.Width = Math.Max(0, SwitchRoot.ActualWidth - fullThumbWidth / 2);
 63 |                 SwitchChecked.Padding = new Thickness(0, 0, (SwitchThumb.ActualWidth + SwitchThumb.BorderThickness.Left) / 2, 0);
 64 |                 SwitchUnchecked.Padding = new Thickness((SwitchThumb.ActualWidth + SwitchThumb.BorderThickness.Right) / 2, 0, 0, 0);
 65 |             }
 66 | 
 67 |             SwitchThumb.Margin = new Thickness(SwitchRoot.ActualWidth - fullThumbWidth, SwitchThumb.Margin.Top, 0, SwitchThumb.Margin.Bottom);
 68 |             UncheckedOffset = -SwitchRoot.ActualWidth + fullThumbWidth - SwitchThumb.BorderThickness.Left;
 69 |             CheckedOffset = SwitchThumb.BorderThickness.Right;
 70 | 
 71 |             if (!IsDragging)
 72 |             {
 73 |                 Offset = IsChecked ? CheckedOffset : UncheckedOffset;
 74 |                 ChangeCheckStates(false);
 75 |             }
 76 |         }
 77 | 
 78 |         protected override void OnDragCompleted(object sender, DragCompletedEventArgs e)
 79 |         {
 80 |             IsDragging = false;
 81 |             bool click = false;
 82 |             double fullThumbWidth = SwitchThumb.ActualWidth + SwitchThumb.BorderThickness.Left + SwitchThumb.BorderThickness.Right;
 83 | 
 84 |             if ((!IsChecked && DragOffset > (SwitchRoot.ActualWidth - fullThumbWidth) * (Elasticity - 1.0))
 85 |                  || (IsChecked && DragOffset < (SwitchRoot.ActualWidth - fullThumbWidth) * -Elasticity))
 86 |             {
 87 |                 double edge = IsChecked ? CheckedOffset : UncheckedOffset;
 88 |                 if (Offset != edge)
 89 |                 {
 90 |                     click = true;
 91 |                 }
 92 |             }
 93 |             else if (DragOffset == CheckedOffset || DragOffset == UncheckedOffset)
 94 |             {
 95 |                 click = true;
 96 |             }
 97 |             else
 98 |             {
 99 |                 ChangeCheckStates(true);
100 |             }
101 | 
102 |             if (click)
103 |             {
104 |                 OnClick();
105 |             }
106 | 
107 |             DragOffset = 0;
108 |         }
109 |     }
110 | }


--------------------------------------------------------------------------------
/Common/Icons/ToggleSwitch.HorizontalToggleSwitch.Expression.Large.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ejensen/toggle-switch-control/1761c450de096c7cea7ec1d81f337ed7f9e69624/Common/Icons/ToggleSwitch.HorizontalToggleSwitch.Expression.Large.png


--------------------------------------------------------------------------------
/Common/Icons/ToggleSwitch.HorizontalToggleSwitch.Expression.Small.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ejensen/toggle-switch-control/1761c450de096c7cea7ec1d81f337ed7f9e69624/Common/Icons/ToggleSwitch.HorizontalToggleSwitch.Expression.Small.png


--------------------------------------------------------------------------------
/Common/Icons/ToggleSwitch.HorizontalToggleSwitch.VisualStudio.bmp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ejensen/toggle-switch-control/1761c450de096c7cea7ec1d81f337ed7f9e69624/Common/Icons/ToggleSwitch.HorizontalToggleSwitch.VisualStudio.bmp


--------------------------------------------------------------------------------
/Common/ToggleSwitchBase.cs:
--------------------------------------------------------------------------------
  1 | //-----------------------------------------------------------------------
  2 | // <copyright file="ToggleSwitchBase.cs">
  3 | // (c) 2011 Eric Jensen. All rights reserved.
  4 | // This source is subject to the Microsoft Public License.
  5 | // See http://www.opensource.org/licenses/MS-PL.
  6 | // </copyright>
  7 | // <date>15-Sept-2011</date>
  8 | // <author>Eric Jensen</author>
  9 | // <summary>Base class for the toggle switch control.</summary>
 10 | //-----------------------------------------------------------------------
 11 | using System;
 12 | using System.ComponentModel;
 13 | using System.Windows;
 14 | using System.Windows.Controls;
 15 | using System.Windows.Controls.Primitives;
 16 | using System.Windows.Input;
 17 | using System.Windows.Media;
 18 | using System.Windows.Media.Animation;
 19 | using ToggleSwitch.Utils;
 20 | 
 21 | namespace ToggleSwitch
 22 | {
 23 |     ///<summary>
 24 |     /// Base class for the toggle switch control.
 25 |     ///</summary>
 26 |     [TemplateVisualState(Name = NormalState, GroupName = CommonStates)]
 27 |     [TemplateVisualState(Name = DisabledState, GroupName = CommonStates)]
 28 |     [TemplateVisualState(Name = MouseOverState, GroupName = CommonStates)]
 29 |     [TemplateVisualState(Name = FocusedState, GroupName = FocusStates)]
 30 |     [TemplateVisualState(Name = UnfocusedState, GroupName = FocusStates)]
 31 |     [TemplateVisualState(Name = CheckedState, GroupName = CheckStates)]
 32 |     [TemplateVisualState(Name = UncheckedState, GroupName = CheckStates)]
 33 |     [TemplateVisualState(Name = DraggingState + CheckedState, GroupName = CheckStates)]
 34 |     [TemplateVisualState(Name = DraggingState + UncheckedState, GroupName = CheckStates)]
 35 |     [TemplatePart(Name = SwitchCheckedPart, Type = typeof(Control))]
 36 |     [TemplatePart(Name = SwitchUncheckedPart, Type = typeof(Control))]
 37 |     [TemplatePart(Name = SwitchThumbPart, Type = typeof(Thumb))]
 38 |     [TemplatePart(Name = SwitchRootPart, Type = typeof(FrameworkElement))]
 39 |     [TemplatePart(Name = SwitchTrackPart, Type = typeof(FrameworkElement))]
 40 |     [Description("A control which when clicked or dragged toggles between on and off states.")]
 41 |     public abstract class ToggleSwitchBase : Control
 42 |     {
 43 |         #region Constants
 44 | 
 45 |         private const string CommonStates = "CommonStates";
 46 |         private const string NormalState = "Normal";
 47 |         private const string DisabledState = "Disabled";
 48 |         private const string MouseOverState = "MouseOver";
 49 | 
 50 |         private const string CheckStates = "CheckStates";
 51 |         private const string CheckedState = "Checked";
 52 |         private const string DraggingState = "Dragging";
 53 |         private const string UncheckedState = "Unchecked";
 54 | 
 55 |         private const string FocusStates = "FocusStates";
 56 |         private const string FocusedState = "Focused";
 57 |         private const string UnfocusedState = "Unfocused";
 58 | 
 59 |         private const string SwitchRootPart = "SwitchRoot";
 60 |         private const string SwitchCheckedPart = "SwitchChecked";
 61 |         private const string SwitchUncheckedPart = "SwitchUnchecked";
 62 |         private const string SwitchThumbPart = "SwitchThumb";
 63 |         private const string SwitchTrackPart = "SwitchTrack";
 64 | 
 65 |         private const string CommonPropertiesCategory = "Common Properties";
 66 |         private const string AppearanceCategory = "Appearance";
 67 | 
 68 |         #endregion
 69 | 
 70 |         #region Fields
 71 | 
 72 |         /// <summary>
 73 |         /// True if the mouse has been captured by this control, false otherwise.
 74 |         /// </summary> 
 75 |         private bool _isMouseCaptured;
 76 | 
 77 |         /// <summary> 
 78 |         /// True if the SPACE key is currently pressed, false otherwise. 
 79 |         /// </summary>
 80 |         private bool _isSpaceKeyDown;
 81 | 
 82 |         /// <summary>
 83 |         /// True if the mouse's left button is currently down, false otherwise. 
 84 |         /// </summary>
 85 |         private bool _isMouseLeftButtonDown;
 86 | 
 87 |         /// <summary> 
 88 |         /// Last known position of the mouse with respect to this Button.
 89 |         /// </summary> 
 90 |         private Point _mousePosition;
 91 | 
 92 |         /// <summary>
 93 |         /// True if visual state changes are suspended; false otherwise. 
 94 |         /// </summary>
 95 |         private bool _suspendStateChanges;
 96 | 
 97 |         #endregion
 98 | 
 99 |         #region Properties
100 | 
101 |         protected Thumb SwitchThumb { get; set; }
102 |         protected Control SwitchChecked { get; set; }
103 |         protected Control SwitchUnchecked { get; set; }
104 |         protected FrameworkElement SwitchRoot { get; set; }
105 |         protected FrameworkElement SwitchTrack { get; set; }
106 | 
107 |         /// <summary>
108 |         /// The current offset of the Thumb.
109 |         /// </summary>
110 |         protected abstract double Offset { get; set; }
111 | 
112 |         /// <summary>
113 |         /// The current offset of the Thumb when it's in the Checked state.
114 |         /// </summary>
115 |         protected double CheckedOffset { get; set; }
116 | 
117 |         /// <summary>
118 |         /// The current offset of the Thumb when it's in the Unchecked state.
119 |         /// </summary>
120 |         protected double UncheckedOffset { get; set; }
121 | 
122 |         /// <summary>
123 |         /// The offset of the thumb while it's being dragged.
124 |         /// </summary>
125 |         protected double DragOffset { get; set; }
126 | 
127 |         /// <summary>
128 |         /// Gets or sets whether the thumb position is being manipulated.
129 |         /// </summary>
130 |         protected bool IsDragging { get; set; }
131 | 
132 |         /// <summary> 
133 |         /// Gets a value that indicates whether a ToggleSwitch is currently pressed.
134 |         /// </summary> 
135 |         public bool IsPressed { get; protected set; }
136 | 
137 |         protected abstract PropertyPath SlidePropertyPath { get; }
138 | 
139 |         #endregion
140 | 
141 |         #region Dependency Properties
142 | 
143 |         #region ContentTemplate (DependencyProperty)
144 | 
145 |         ///<summary>
146 |         /// DependencyProperty for the <see cref="ControlTemplate">ControlTemplate</see> property.
147 |         ///</summary>
148 |         public static readonly DependencyProperty ContentTemplateProperty =
149 |             DependencyProperty.Register("ContentTemplate", typeof(ControlTemplate), typeof(ToggleSwitchBase),
150 |             new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsArrange | FrameworkPropertyMetadataOptions.AffectsMeasure, OnLayoutDependancyPropertyChanged));
151 | 
152 |         ///<summary>
153 |         /// The template applied to the <see cref="CheckedContent">Checked</see> and <see cref="UncheckedContent">Unchecked</see> content properties.
154 |         ///</summary>
155 |         [Description("The template applied to the Checked and Unchecked content properties.")]
156 |         public ControlTemplate ContentTemplate
157 |         {
158 |             get { return (ControlTemplate)GetValue(ContentTemplateProperty); }
159 |             set { SetValue(ContentTemplateProperty, value); }
160 |         }
161 | 
162 |         #endregion
163 | 
164 |         #region CheckedContent (Dependency Property)
165 | 
166 |         ///<summary>
167 |         /// DependencyProperty for the <see cref="CheckedContent">CheckedContent</see> property.
168 |         ///</summary>
169 |         public static readonly DependencyProperty CheckedContentProperty =
170 |             DependencyProperty.Register("CheckedContent", typeof(object), typeof(ToggleSwitchBase),
171 |             new FrameworkPropertyMetadata("ON", FrameworkPropertyMetadataOptions.AffectsArrange, OnLayoutDependancyPropertyChanged));
172 | 
173 |         ///<summary>
174 |         /// The content shown on the checked side of the toggle switch
175 |         ///</summary>
176 |         [Category(CommonPropertiesCategory)]
177 |         [Description("The content shown on the checked side of the toggle switch")]
178 |         public object CheckedContent
179 |         {
180 |             get { return GetValue(CheckedContentProperty); }
181 |             set { SetValue(CheckedContentProperty, value); }
182 |         }
183 | 
184 |         #endregion
185 | 
186 |         #region CheckedForeground (Dependency Property)
187 | 
188 |         ///<summary>
189 |         /// DependencyProperty for the <see cref="CheckedForeground">CheckedForeground</see> property.
190 |         ///</summary>
191 |         public static readonly DependencyProperty CheckedForegroundProperty =
192 |             DependencyProperty.Register("CheckedForeground", typeof(Brush), typeof(ToggleSwitchBase), null);
193 | 
194 |         ///<summary>
195 |         /// The brush used for the foreground of the checked side of the toggle switch.
196 |         ///</summary>
197 |         [Description("The brush used for the foreground of the checked side of the toggle switch.")]
198 |         public Brush CheckedForeground
199 |         {
200 |             get { return (Brush)GetValue(CheckedForegroundProperty); }
201 |             set { SetValue(CheckedForegroundProperty, value); }
202 |         }
203 | 
204 |         #endregion
205 | 
206 |         #region CheckedBackground (Dependency Property)
207 | 
208 |         ///<summary>
209 |         /// DependencyProperty for the <see cref="CheckedBackground">CheckedBackground</see> property.
210 |         ///</summary>
211 |         public static readonly DependencyProperty CheckedBackgroundProperty =
212 |             DependencyProperty.Register("CheckedBackground", typeof(Brush), typeof(ToggleSwitchBase), null);
213 | 
214 |         ///<summary>
215 |         /// The brush used for the background of the checked side of the toggle switch.
216 |         ///</summary>
217 |         [Description("The brush used for the background of the checked side of the toggle switch.")]
218 |         public Brush CheckedBackground
219 |         {
220 |             get { return (Brush)GetValue(CheckedBackgroundProperty); }
221 |             set { SetValue(CheckedBackgroundProperty, value); }
222 |         }
223 | 
224 |         #endregion
225 | 
226 |         #region UncheckedContent (Dependency Property)
227 | 
228 |         ///<summary>
229 |         /// DependencyProperty for the <see cref="UncheckedContent">UncheckedContent</see> property.
230 |         ///</summary>
231 |         public static readonly DependencyProperty UncheckedContentProperty =
232 |             DependencyProperty.Register("UncheckedContent", typeof(object), typeof(ToggleSwitchBase),
233 |             new FrameworkPropertyMetadata("OFF", FrameworkPropertyMetadataOptions.AffectsArrange, OnLayoutDependancyPropertyChanged));
234 | 
235 |         ///<summary>
236 |         /// The content shown on the unchecked side of the toggle switch.
237 |         ///</summary>
238 |         [Category(CommonPropertiesCategory)]
239 |         [Description("The content shown on the unchecked side of the toggle switch.")]
240 |         public object UncheckedContent
241 |         {
242 |             get { return GetValue(UncheckedContentProperty); }
243 |             set { SetValue(UncheckedContentProperty, value); }
244 |         }
245 | 
246 |         #endregion
247 | 
248 |         #region UncheckedForeground (Dependency Property)
249 | 
250 |         ///<summary>
251 |         /// DependencyProperty for the <see cref="UncheckedForeground">UncheckedForeground</see> property.
252 |         ///</summary>
253 |         public static readonly DependencyProperty UncheckedForegroundProperty =
254 |             DependencyProperty.Register("UncheckedForeground", typeof(Brush), typeof(ToggleSwitchBase), null);
255 | 
256 |         ///<summary>
257 |         /// The brush used for the foreground of the Unchecked side of the toggle switch.
258 |         ///</summary>
259 |         [Description("The brush used for the foreground of the Unchecked side of the toggle switch.")]
260 |         public Brush UncheckedForeground
261 |         {
262 |             get { return (Brush)GetValue(UncheckedForegroundProperty); }
263 |             set { SetValue(UncheckedForegroundProperty, value); }
264 |         }
265 | 
266 |         #endregion
267 | 
268 |         #region UncheckedBackground (Dependency Property)
269 | 
270 |         ///<summary>
271 |         /// DependencyProperty for the <see cref="UncheckedBackground">UncheckedBackground</see> property.
272 |         ///</summary>
273 |         public static readonly DependencyProperty UncheckedBackgroundProperty =
274 |             DependencyProperty.Register("UncheckedBackground", typeof(Brush), typeof(ToggleSwitchBase), null);
275 | 
276 |         ///<summary>
277 |         /// The brush used for the background of the Unchecked side of the toggle switch.
278 |         ///</summary>
279 |         [Description("The brush used for the background of the Unchecked side of the toggle switch.")]
280 |         public Brush UncheckedBackground
281 |         {
282 |             get { return (Brush)GetValue(UncheckedBackgroundProperty); }
283 |             set { SetValue(UncheckedBackgroundProperty, value); }
284 |         }
285 | 
286 |         #endregion
287 | 
288 |         #region Elasticity (Dependency Property)
289 | 
290 |         ///<summary>
291 |         /// DependencyProperty for the <see cref="Elasticity">Elasticity</see> property.
292 |         ///</summary>
293 |         public static readonly DependencyProperty ElasticityProperty =
294 |             DependencyProperty.Register("Elasticity", typeof(double), typeof(ToggleSwitchBase), new PropertyMetadata(0.5));
295 | 
296 |         ///<summary>
297 |         /// Determines the percentage of the way the <see cref="Thumb">thumb</see> must be dragged before the switch changes it's <see cref="IsChecked">IsChecked</see> state.
298 |         ///</summary>
299 |         ///<remarks>
300 |         /// This value must be within the range of 0.0 - 1.0. 
301 |         ///</remarks>
302 |         [Category(CommonPropertiesCategory)]
303 |         [Description("Determines the percentage of the way the thumb must be dragged before the switch changes it's IsChecked state.")]
304 |         public double Elasticity
305 |         {
306 |             get { return ((double)GetValue(ElasticityProperty)).Clamp(0.0, 1.0); }
307 |             set { SetValue(ElasticityProperty, value.Clamp(0, 1.0)); }
308 |         }
309 | 
310 |         #endregion
311 | 
312 |         #region ThumbTemplate (DependencyProperty)
313 | 
314 |         ///<summary>
315 |         /// DependencyProperty for the <see cref="ThumbTemplate">ThumbTemplate</see> property.
316 |         ///</summary>
317 |         public static readonly DependencyProperty ThumbTemplateProperty =
318 |             DependencyProperty.Register("ThumbTemplate", typeof(ControlTemplate), typeof(ToggleSwitchBase),
319 |             new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsArrange | FrameworkPropertyMetadataOptions.AffectsMeasure, OnLayoutDependancyPropertyChanged));
320 | 
321 |         ///<summary>
322 |         /// The <see cref="Thumb">thumb's</see> control template.
323 |         ///</summary>
324 |         [Description("The thumb's control template.")]
325 |         public ControlTemplate ThumbTemplate
326 |         {
327 |             get { return (ControlTemplate)GetValue(ThumbTemplateProperty); }
328 |             set { SetValue(ThumbTemplateProperty, value); }
329 |         }
330 | 
331 |         #endregion
332 | 
333 |         #region ThumbBrush (Dependency Property)
334 | 
335 |         ///<summary>
336 |         /// DependencyProperty for the <see cref="ThumbBrush">ThumbBrush</see> property.
337 |         ///</summary>
338 |         public static readonly DependencyProperty ThumbBrushProperty =
339 |             DependencyProperty.Register("ThumbBrush", typeof(Brush), typeof(ToggleSwitchBase), null);
340 | 
341 |         ///<summary>
342 |         /// The brush used to fill the <see cref="Thumb">thumb</see>.
343 |         ///</summary>
344 |         [Description("The brush used to fill the thumb.")]
345 |         public Brush ThumbBrush
346 |         {
347 |             get { return (Brush)GetValue(ThumbBrushProperty); }
348 |             set { SetValue(ThumbBrushProperty, value); }
349 |         }
350 | 
351 |         #endregion
352 | 
353 |         #region ThumbSize (DependencyProperty)
354 | 
355 |         ///<summary>
356 |         /// DependencyProperty for the <see cref="ThumbSize">ThumbSize</see> property.
357 |         ///</summary>
358 |         public static readonly DependencyProperty ThumbSizeProperty =
359 |             DependencyProperty.Register("ThumbSize", typeof(double), typeof(ToggleSwitchBase),
360 |             new FrameworkPropertyMetadata(40.0, FrameworkPropertyMetadataOptions.AffectsArrange | FrameworkPropertyMetadataOptions.AffectsMeasure, OnLayoutDependancyPropertyChanged));
361 | 
362 |         ///<summary>
363 |         /// The size of the toggle switch's <see cref="Thumb">thumb</see>.
364 |         ///</summary>
365 |         [Category(AppearanceCategory)]
366 |         [Description("The size of the toggle switch's thumb.")]
367 |         public double ThumbSize
368 |         {
369 |             get { return (double)GetValue(ThumbSizeProperty); }
370 |             set { SetValue(ThumbSizeProperty, value); }
371 |         }
372 | 
373 |         #endregion
374 | 
375 |         #region IsChecked (DependencyProperty)
376 | 
377 |         ///<summary>
378 |         /// DependencyProperty for the <see cref="IsChecked">IsChecked</see> property.
379 |         ///</summary>
380 |         public static readonly DependencyProperty IsCheckedProperty =
381 |             DependencyProperty.Register("IsChecked", typeof(bool), typeof(ToggleSwitchBase),
382 |             new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsArrange | FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnIsCheckedChanged));
383 | 
384 |         ///<summary>
385 |         /// Gets or sets whether the control is in the checked state.
386 |         ///</summary>
387 |         [Category(CommonPropertiesCategory)]
388 |         [Description("Gets or sets whether the control is in the checked state.")]
389 |         public bool IsChecked
390 |         {
391 |             get { return (bool)GetValue(IsCheckedProperty); }
392 |             set { SetValue(IsCheckedProperty, value); }
393 |         }
394 | 
395 |         private static void OnIsCheckedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
396 |         {
397 |             var control = (ToggleSwitchBase)d;
398 | 
399 |             if (e.NewValue != e.OldValue)
400 |             {
401 |                 if ((bool)e.NewValue)
402 |                 {
403 |                     control.InvokeChecked(new RoutedEventArgs());
404 |                 }
405 |                 else
406 |                 {
407 |                     control.InvokeUnchecked(new RoutedEventArgs());
408 |                 }
409 |             }
410 | 
411 |             control.ChangeCheckStates(true);
412 |         }
413 | 
414 |         #endregion
415 | 
416 |         #endregion
417 | 
418 |         #region Events
419 | 
420 |         ///<summary>
421 |         /// Event raised when the toggle switch is unchecked.
422 |         ///</summary>
423 |         public event RoutedEventHandler Unchecked;
424 | 
425 |         protected void InvokeUnchecked(RoutedEventArgs e)
426 |         {
427 |             Unchecked?.Invoke(this, e);
428 |         }
429 | 
430 |         ///<summary>
431 |         /// Event raised when the toggle switch is checked.
432 |         ///</summary>
433 |         public event RoutedEventHandler Checked;
434 | 
435 |         protected void InvokeChecked(RoutedEventArgs e)
436 |         {
437 |             Checked?.Invoke(this, e);
438 |         }
439 | 
440 |         #endregion
441 | 
442 |         /// <summary> 
443 |         /// Initializes a new instance of the ToggleSwitchBase class.
444 |         /// </summary>
445 |         protected ToggleSwitchBase()
446 |         {
447 |             Loaded += delegate { UpdateVisualState(false); };
448 |             IsEnabledChanged += OnIsEnabledChanged;
449 |         }
450 | 
451 |         /// <summary>
452 |         /// Raised while dragging the <see cref="Thumb">Thumb</see>.
453 |         /// </summary>
454 |         /// <param name="sender"></param>
455 |         /// <param name="e"></param>
456 |         protected abstract void OnDragDelta(object sender, DragDeltaEventArgs e);
457 | 
458 |         /// <summary>
459 |         /// Raised when the dragging of the <see cref="Thumb">Thumb</see> has completed.
460 |         /// </summary>
461 |         /// <param name="sender"></param>
462 |         /// <param name="e"></param>
463 |         protected abstract void OnDragCompleted(object sender, DragCompletedEventArgs e);
464 | 
465 |         /// <summary>
466 |         /// Recalculated the layout of the control.
467 |         /// </summary>
468 |         protected abstract void LayoutControls();
469 | 
470 |         public override void OnApplyTemplate()
471 |         {
472 |             base.OnApplyTemplate();
473 | 
474 |             RemoveEventHandlers();
475 |             GetTemplateChildren();
476 |             AddEventHandlers();
477 | 
478 |             LayoutControls();
479 | 
480 |             VisualStateManager.GoToState(this, IsEnabled ? NormalState : DisabledState, false);
481 |             ChangeCheckStates(false);
482 |         }
483 | 
484 |         /// <summary>
485 |         /// Initializes the control's template parts.
486 |         /// </summary>
487 |         protected virtual void GetTemplateChildren()
488 |         {
489 |             SwitchRoot = GetTemplateChild(SwitchRootPart) as FrameworkElement;
490 |             SwitchThumb = GetTemplateChild(SwitchThumbPart) as Thumb;
491 |             SwitchChecked = GetTemplateChild(SwitchCheckedPart) as Control;
492 |             SwitchUnchecked = GetTemplateChild(SwitchUncheckedPart) as Control;
493 |             SwitchTrack = GetTemplateChild(SwitchTrackPart) as FrameworkElement;
494 |         }
495 | 
496 |         /// <summary>
497 |         /// Subscribe event listeners.
498 |         /// </summary>
499 |         protected virtual void AddEventHandlers()
500 |         {
501 |             if (SwitchThumb != null)
502 |             {
503 |                 SwitchThumb.DragStarted += OnDragStarted;
504 |                 SwitchThumb.DragDelta += OnDragDelta;
505 |                 SwitchThumb.DragCompleted += OnDragCompleted;
506 |             }
507 |             SizeChanged += OnSizeChanged;
508 |         }
509 | 
510 |         /// <summary>
511 |         /// Unsubscribe event listeners.
512 |         /// </summary>
513 |         protected virtual void RemoveEventHandlers()
514 |         {
515 |             if (SwitchThumb != null)
516 |             {
517 |                 SwitchThumb.DragStarted -= OnDragStarted;
518 |                 SwitchThumb.DragDelta -= OnDragDelta;
519 |                 SwitchThumb.DragCompleted -= OnDragCompleted;
520 |             }
521 |             SizeChanged -= OnSizeChanged;
522 |         }
523 | 
524 |         /// <summary>
525 |         /// Raised when a drag has started on the <see cref="Thumb">Thumb</see>.
526 |         /// </summary>
527 |         /// <param name="sender"></param>
528 |         /// <param name="e"></param>
529 |         protected virtual void OnDragStarted(object sender, DragStartedEventArgs e)
530 |         {
531 |             IsDragging = true;
532 |             DragOffset = Offset;
533 |             ChangeCheckStates(false);
534 |         }
535 | 
536 |         /// <summary>
537 |         /// Called when the control is clicked.
538 |         /// </summary>
539 |         protected void OnClick()
540 |         {
541 |             SetCurrentValue(IsCheckedProperty, !IsChecked);
542 |         }
543 | 
544 |         /// <summary>
545 |         /// Raised when the size of the control has changed.
546 |         /// </summary>
547 |         /// <param name="sender"></param>
548 |         /// <param name="e"></param>
549 |         protected virtual void OnSizeChanged(object sender, SizeChangedEventArgs e)
550 |         {
551 |             LayoutControls();
552 |         }
553 | 
554 |         /// <summary> 
555 |         /// Capture the mouse. 
556 |         /// </summary>
557 |         internal void CaptureMouseInternal()
558 |         {
559 |             if (!_isMouseCaptured)
560 |             {
561 |                 _isMouseCaptured = CaptureMouse();
562 |             }
563 |         }
564 | 
565 |         /// <summary>
566 |         /// Release mouse capture if we already had it. 
567 |         /// </summary>
568 |         protected internal void ReleaseMouseCaptureInternal()
569 |         {
570 |             ReleaseMouseCapture();
571 |             _isMouseCaptured = false;
572 |         }
573 | 
574 |         /// <summary>
575 |         /// Raised when a dependency property that affects the control's layout has changed.
576 |         /// </summary>
577 |         /// <param name="d">The ToggleSwitch control</param>
578 |         /// <param name="e"></param>
579 |         private static void OnLayoutDependancyPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
580 |         {
581 |             if (e.NewValue != e.OldValue)
582 |             {
583 |                 ((ToggleSwitchBase)d).LayoutControls();
584 |             }
585 |         }
586 | 
587 |         /// <summary>
588 |         /// Called when the IsEnabled property changes.
589 |         /// </summary>
590 |         /// <param name="sender"></param>
591 |         /// <param name="e"></param>
592 |         private void OnIsEnabledChanged(object sender, DependencyPropertyChangedEventArgs e)
593 |         {
594 |             _suspendStateChanges = true;
595 |             if (!IsEnabled)
596 |             {
597 |                 IsPressed = false;
598 |                 _isMouseCaptured = false;
599 |                 _isSpaceKeyDown = false;
600 |                 _isMouseLeftButtonDown = false;
601 |             }
602 | 
603 |             _suspendStateChanges = false;
604 |             UpdateVisualState();
605 |         }
606 | 
607 |         /// <summary> 
608 |         /// Responds to the LostFocus event.
609 |         /// </summary> 
610 |         /// <param name="e">The event data for the LostFocus event.</param>
611 |         protected override void OnLostFocus(RoutedEventArgs e)
612 |         {
613 |             base.OnLostFocus(e);
614 |             IsPressed = false;
615 |             ReleaseMouseCaptureInternal();
616 |             _isSpaceKeyDown = false;
617 | 
618 |             _suspendStateChanges = false;
619 |             UpdateVisualState();
620 |         }
621 | 
622 |         /// <summary> 
623 |         /// Responds to the KeyDown event.
624 |         /// </summary> 
625 |         /// <param name="e">The event data for the KeyDown event.</param>
626 |         protected override void OnKeyDown(KeyEventArgs e)
627 |         {
628 |             base.OnKeyDown(e);
629 |             if (e.Handled)
630 |             {
631 |                 return;
632 |             }
633 | 
634 |             if (OnKeyDownInternal(e.Key))
635 |             {
636 |                 e.Handled = true;
637 |             }
638 |         }
639 | 
640 |         /// <summary> 
641 |         /// Handles the KeyDown event for ButtonBase.
642 |         /// </summary> 
643 |         /// <param name="key">
644 |         /// The keyboard key associated with the event.
645 |         /// </param> 
646 |         /// <returns>True if the event was handled, false otherwise.</returns>
647 |         /// <remarks>
648 |         /// This method exists for the purpose of unit testing since we can't 
649 |         /// set KeyEventArgs.Key to simulate key press events. 
650 |         /// </remarks>
651 |         private bool OnKeyDownInternal(Key key)
652 |         {
653 |             bool handled = false;
654 | 
655 |             if (IsEnabled)
656 |             {
657 |                 if (key == Key.Space)
658 |                 {
659 |                     if (!_isMouseCaptured && !_isSpaceKeyDown)
660 |                     {
661 |                         _isSpaceKeyDown = true;
662 |                         IsPressed = true;
663 |                         CaptureMouseInternal();
664 | 
665 |                         handled = true;
666 |                     }
667 |                 }
668 |                 else if (key == Key.Enter)
669 |                 {
670 |                     _isSpaceKeyDown = false;
671 |                     IsPressed = false;
672 |                     ReleaseMouseCaptureInternal();
673 | 
674 |                     OnClick();
675 | 
676 |                     handled = true;
677 |                 }
678 |                 else if (_isSpaceKeyDown)
679 |                 {
680 |                     IsPressed = false;
681 |                     _isSpaceKeyDown = false;
682 |                     ReleaseMouseCaptureInternal();
683 |                 }
684 |             }
685 | 
686 |             return handled;
687 |         }
688 | 
689 |         /// <summary> 
690 |         /// Responds to the KeyUp event. 
691 |         /// </summary>
692 |         /// <param name="e">The event data for the KeyUp event.</param> 
693 |         protected override void OnKeyUp(KeyEventArgs e)
694 |         {
695 |             base.OnKeyUp(e);
696 |             if (e.Handled)
697 |             {
698 |                 return;
699 |             }
700 | 
701 |             if (OnKeyUpInternal(e.Key))
702 |             {
703 |                 e.Handled = true;
704 |             }
705 |         }
706 | 
707 |         /// <summary> 
708 |         /// Handles the KeyUp event for ButtonBase. 
709 |         /// </summary>
710 |         /// <param name="key">The keyboard key associated with the event.</param> 
711 |         /// <returns>True if the event was handled, false otherwise.</returns>
712 |         /// <remarks>
713 |         /// This method exists for the purpose of unit testing since we can't 
714 |         /// set KeyEventArgs.Key to simulate key press events.
715 |         /// </remarks>
716 |         private bool OnKeyUpInternal(Key key)
717 |         {
718 |             bool handled = false;
719 | 
720 |             if (IsEnabled && (key == Key.Space))
721 |             {
722 |                 _isSpaceKeyDown = false;
723 | 
724 |                 if (!_isMouseLeftButtonDown)
725 |                 {
726 |                     ReleaseMouseCaptureInternal();
727 |                     if (IsPressed)
728 |                     {
729 |                         OnClick();
730 |                     }
731 | 
732 |                     IsPressed = false;
733 |                 }
734 |                 else if (_isMouseCaptured)
735 |                 {
736 |                     bool isValid = IsValidMousePosition();
737 |                     IsPressed = isValid;
738 |                     if (!isValid)
739 |                     {
740 |                         ReleaseMouseCaptureInternal();
741 |                     }
742 |                 }
743 | 
744 |                 handled = true;
745 |             }
746 | 
747 |             return handled;
748 |         }
749 | 
750 |         /// <summary> 
751 |         /// Responds to the MouseLeftButtonDown event.
752 |         /// </summary>
753 |         /// <param name="e"> 
754 |         /// The event data for the MouseLeftButtonDown event.
755 |         /// </param>
756 |         protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
757 |         {
758 |             base.OnMouseLeftButtonDown(e);
759 |             if (e.Handled)
760 |             {
761 |                 return;
762 |             }
763 | 
764 |             _isMouseLeftButtonDown = true;
765 | 
766 |             if (!IsEnabled)
767 |             {
768 |                 return;
769 |             }
770 | 
771 |             e.Handled = true;
772 |             _suspendStateChanges = true;
773 |             Focus();
774 | 
775 |             CaptureMouseInternal();
776 |             if (_isMouseCaptured)
777 |             {
778 |                 IsPressed = true;
779 |             }
780 | 
781 |             _suspendStateChanges = false;
782 |             UpdateVisualState();
783 |         }
784 | 
785 |         /// <summary> 
786 |         /// Responds to the MouseLeftButtonUp event.
787 |         /// </summary>
788 |         /// <param name="e"> 
789 |         /// The event data for the MouseLeftButtonUp event.
790 |         /// </param>
791 |         protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
792 |         {
793 |             base.OnMouseLeftButtonUp(e);
794 |             if (e.Handled)
795 |             {
796 |                 return;
797 |             }
798 | 
799 |             _isMouseLeftButtonDown = false;
800 | 
801 |             if (!IsEnabled)
802 |             {
803 |                 return;
804 |             }
805 | 
806 |             e.Handled = true;
807 |             if (!_isSpaceKeyDown && IsPressed)
808 |             {
809 |                 OnClick();
810 |             }
811 | 
812 |             if (!_isSpaceKeyDown)
813 |             {
814 |                 ReleaseMouseCaptureInternal();
815 |                 IsPressed = false;
816 |             }
817 |         }
818 | 
819 |         /// <summary> 
820 |         /// Responds to the MouseMove event.
821 |         /// </summary> 
822 |         /// <param name="e">The event data for the MouseMove event.</param>
823 |         protected override void OnMouseMove(MouseEventArgs e)
824 |         {
825 |             base.OnMouseMove(e);
826 |             _mousePosition = e.GetPosition(this);
827 | 
828 |             if (_isMouseLeftButtonDown &&
829 |                  IsEnabled &&
830 |                  _isMouseCaptured &&
831 |                  !_isSpaceKeyDown)
832 |             {
833 |                 IsPressed = IsValidMousePosition();
834 |             }
835 |         }
836 | 
837 |         /// <summary>
838 |         /// Determine if the mouse is above the button based on its last known 
839 |         /// position.
840 |         /// </summary>
841 |         /// <returns> 
842 |         /// True if the mouse is considered above the button, false otherwise. 
843 |         /// </returns>
844 |         private bool IsValidMousePosition()
845 |         {
846 |             return (_mousePosition.X >= 0.0) &&
847 |                      (_mousePosition.X <= ActualWidth) &&
848 |                      (_mousePosition.Y >= 0.0) &&
849 |                      (_mousePosition.Y <= ActualHeight);
850 |         }
851 | 
852 |         protected bool GoToState(bool useTransitions, string stateName)
853 |         {
854 |             return VisualStateManager.GoToState(this, stateName, useTransitions);
855 |         }
856 | 
857 |         protected virtual void ChangeVisualState(bool useTransitions)
858 |         {
859 |             if (!IsEnabled)
860 |             {
861 |                 GoToState(useTransitions, DisabledState);
862 |             }
863 |             else
864 |             {
865 |                 GoToState(useTransitions, IsMouseOver ? MouseOverState : NormalState);
866 |             }
867 | 
868 |             if (IsFocused && IsEnabled)
869 |             {
870 |                 GoToState(useTransitions, FocusedState);
871 |             }
872 |             else
873 |             {
874 |                 GoToState(useTransitions, UnfocusedState);
875 |             }
876 |         }
877 | 
878 |         protected void UpdateVisualState(bool useTransitions = true)
879 |         {
880 |             if (!_suspendStateChanges)
881 |             {
882 |                 ChangeVisualState(useTransitions);
883 |             }
884 |         }
885 | 
886 |         /// <summary>
887 |         /// Updates the control's layout to reflect the current <see cref="IsChecked">IsChecked</see> state.
888 |         /// </summary>
889 |         /// <param name="useTransitions">Whether to use transitions during the layout change.</param>
890 |         protected virtual void ChangeCheckStates(bool useTransitions)
891 |         {
892 |             var state = IsChecked ? CheckedState : UncheckedState;
893 | 
894 |             if (IsDragging)
895 |             {
896 |                 VisualStateManager.GoToState(this, DraggingState + state, useTransitions);
897 |             }
898 |             else
899 |             {
900 |                 VisualStateManager.GoToState(this, state, useTransitions);
901 |                 if (SwitchThumb != null)
902 |                 {
903 |                     VisualStateManager.GoToState(SwitchThumb, state, useTransitions);
904 |                 }
905 |             }
906 | 
907 |             if (SwitchThumb == null || SwitchTrack == null)
908 |             {
909 |                 return;
910 |             }
911 | 
912 |             var storyboard = new Storyboard();
913 |             var duration = new Duration(useTransitions ? TimeSpan.FromMilliseconds(100) : TimeSpan.Zero);
914 |             var backgroundAnimation = new DoubleAnimation();
915 |             var thumbAnimation = new DoubleAnimation();
916 | 
917 |             backgroundAnimation.Duration = duration;
918 |             thumbAnimation.Duration = duration;
919 | 
920 |             double offset = IsChecked ? CheckedOffset : UncheckedOffset;
921 |             backgroundAnimation.To = offset;
922 |             thumbAnimation.To = offset;
923 | 
924 |             storyboard.Children.Add(backgroundAnimation);
925 |             storyboard.Children.Add(thumbAnimation);
926 | 
927 |             Storyboard.SetTarget(backgroundAnimation, SwitchTrack);
928 |             Storyboard.SetTarget(thumbAnimation, SwitchThumb);
929 | 
930 |             Storyboard.SetTargetProperty(backgroundAnimation, SlidePropertyPath);
931 |             Storyboard.SetTargetProperty(thumbAnimation, SlidePropertyPath);
932 | 
933 |             storyboard.Begin();
934 |         }
935 |     }
936 | }
937 | 


--------------------------------------------------------------------------------
/Common/Utils/ActualSizePropertyProxy.cs:
--------------------------------------------------------------------------------
 1 | using System.ComponentModel;
 2 | using System.Windows;
 3 | 
 4 | namespace ToggleSwitch.Utils
 5 | {
 6 |     public class ActualSizePropertyProxy : FrameworkElement, INotifyPropertyChanged
 7 |     {
 8 |         public event PropertyChangedEventHandler PropertyChanged;
 9 | 
10 |         #region ElementProperty (Dependancy Property)
11 | 
12 |         public static readonly DependencyProperty ElementProperty =
13 |             DependencyProperty.Register("Element", typeof(FrameworkElement), typeof(ActualSizePropertyProxy),
14 |                                         new PropertyMetadata(null, OnElementPropertyChanged));
15 | 
16 |         private static void OnElementPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
17 |         {
18 |             if (d != null)
19 |             {
20 |                 ((ActualSizePropertyProxy)d).OnElementChanged(e);
21 |             }
22 |         }
23 | 
24 |         public FrameworkElement Element
25 |         {
26 |             get { return (FrameworkElement)GetValue(ElementProperty); }
27 |             set { SetValue(ElementProperty, value); }
28 |         }
29 | 
30 |         #endregion
31 | 
32 |         public double ActualHeightValue
33 |         {
34 |             get { return Element == null ? 0 : Element.ActualHeight; }
35 |         }
36 | 
37 |         public double ActualWidthValue
38 |         {
39 |             get { return Element == null ? 0 : Element.ActualWidth; }
40 |         }
41 | 
42 |         private void OnElementChanged(DependencyPropertyChangedEventArgs e)
43 |         {
44 |             var oldElement = (FrameworkElement)e.OldValue;
45 |             var newElement = (FrameworkElement)e.NewValue;
46 | 
47 |             if (oldElement != null)
48 |             {
49 |                 oldElement.SizeChanged -= ElementSizeChanged;
50 |             }
51 | 
52 |             if (newElement != null)
53 |             {
54 |                 newElement.SizeChanged += ElementSizeChanged;
55 |             }
56 | 
57 |             NotifyPropertyChanged();
58 |         }
59 | 
60 |         private void ElementSizeChanged(object sender, SizeChangedEventArgs e)
61 |         {
62 |             NotifyPropertyChanged();
63 |         }
64 | 
65 |         private void NotifyPropertyChanged()
66 |         {
67 |             if (PropertyChanged != null)
68 |             {
69 |                 PropertyChanged(this, new PropertyChangedEventArgs(nameof(ActualWidthValue)));
70 |                 PropertyChanged(this, new PropertyChangedEventArgs(nameof(ActualHeightValue)));
71 |             }
72 |         }
73 |     }
74 | }


--------------------------------------------------------------------------------
/Common/Utils/CornerRadiusValueConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows;
 4 | using System.Windows.Data;
 5 | 
 6 | namespace Demo.Utils
 7 | {
 8 |     public class CornerRadiusValueConverter : IValueConverter
 9 |     {
10 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
11 |         {
12 |             var radius = Double.Parse(value.ToString(), culture);
13 |             if (parameter != null)
14 |             {
15 |                 radius *= Double.Parse(parameter.ToString(), culture);
16 |             }
17 |             return new CornerRadius(radius);
18 |         }
19 | 
20 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
21 |         {
22 |             throw new NotImplementedException();
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Common/Utils/HelperExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace ToggleSwitch.Utils
 4 | {
 5 |     internal static class HelperExtensions
 6 |     {
 7 |         public static T Clamp<T>(this T val, T min, T max) where T : IComparable<T>
 8 |         {
 9 |             return val.CompareTo(min) < 0 ? min : (val.CompareTo(max) > 0 ? max : val);
10 |         }
11 |     }
12 | }


--------------------------------------------------------------------------------
/Common/Utils/ScalarValueConverter.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Globalization;
 3 | using System.Windows.Data;
 4 | 
 5 | namespace Demo.Utils
 6 | {
 7 |     public class ScalarValueConverter : IValueConverter
 8 |     {
 9 |         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
10 |         {
11 |             var oldValue = Double.Parse(value.ToString(), culture);
12 |             if (parameter != null)
13 |             {
14 |                 oldValue *= Double.Parse(parameter.ToString(), culture);
15 |             }
16 |             return oldValue;
17 |         }
18 | 
19 |         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
20 |         {
21 |             var oldValue = Double.Parse(value.ToString(), culture);
22 |             if (parameter != null)
23 |             {
24 |                 oldValue /= Double.Parse(parameter.ToString(), culture);
25 |             }
26 |             return oldValue;
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Common/VerticalToggleSwitch.cs:
--------------------------------------------------------------------------------
  1 | //-----------------------------------------------------------------------
  2 | // <copyright file="VerticalToggleSwitch.cs">
  3 | // (c) 2011 Eric Jensen. All rights reserved.
  4 | // This source is subject to the Microsoft Public License.
  5 | // See http://www.opensource.org/licenses/MS-PL.
  6 | // </copyright>
  7 | // <date>15-Sept-2011</date>
  8 | // <author>Eric Jensen</author>
  9 | // <summary>Vertically oriented toggle switch control.</summary>
 10 | //-----------------------------------------------------------------------
 11 | using System;
 12 | using System.Windows;
 13 | using System.Windows.Controls;
 14 | using System.Windows.Controls.Primitives;
 15 | using ToggleSwitch;
 16 | 
 17 | namespace Demo.Controls
 18 | {
 19 |     ///<summary>
 20 |     /// Vertically oriented toggle switch control.
 21 |     ///</summary>
 22 |     public class VerticalToggleSwitch : ToggleSwitchBase
 23 |     {
 24 |         public VerticalToggleSwitch()
 25 |         {
 26 |             DefaultStyleKey = typeof(VerticalToggleSwitch);
 27 |         }
 28 | 
 29 |         protected override double Offset
 30 |         {
 31 |             get { return Canvas.GetTop(SwitchThumb); }
 32 |             set
 33 |             {
 34 |                 SwitchTrack.BeginAnimation(Canvas.TopProperty, null);
 35 |                 SwitchThumb.BeginAnimation(Canvas.TopProperty, null);
 36 |                 Canvas.SetTop(SwitchThumb, value);
 37 |                 Canvas.SetTop(SwitchTrack, value);
 38 |             }
 39 |         }
 40 | 
 41 |         protected override PropertyPath SlidePropertyPath
 42 |         {
 43 |             get { return new PropertyPath("(Canvas.Top)"); }
 44 |         }
 45 | 
 46 |         protected override void OnDragDelta(object sender, DragDeltaEventArgs e)
 47 |         {
 48 |             DragOffset += e.VerticalChange;
 49 |             Offset = Math.Min(UncheckedOffset, Math.Max(CheckedOffset, DragOffset));
 50 |         }
 51 | 
 52 |         protected override void LayoutControls()
 53 |         {
 54 |             if (SwitchThumb == null || SwitchRoot == null)
 55 |             {
 56 |                 return;
 57 |             }
 58 | 
 59 |             double fullThumbHeight = SwitchThumb.ActualHeight + SwitchThumb.BorderThickness.Top + SwitchThumb.BorderThickness.Bottom;
 60 | 
 61 |             if (SwitchChecked != null && SwitchUnchecked != null)
 62 |             {
 63 |                 SwitchChecked.Height = SwitchUnchecked.Height = Math.Max(0, SwitchRoot.ActualHeight - fullThumbHeight / 2);
 64 |                 SwitchChecked.Padding = new Thickness(0, 0, 0, (SwitchThumb.ActualHeight + +SwitchThumb.BorderThickness.Bottom) / 2);
 65 |                 SwitchUnchecked.Padding = new Thickness(0, (SwitchThumb.ActualHeight + +SwitchThumb.BorderThickness.Top) / 2, 0, 0);
 66 |             }
 67 | 
 68 |             UncheckedOffset = SwitchRoot.ActualHeight - SwitchThumb.ActualHeight - SwitchThumb.Margin.Top - SwitchThumb.Margin.Bottom;
 69 |             CheckedOffset = 0;
 70 | 
 71 |             if (!IsDragging)
 72 |             {
 73 |                 Offset = IsChecked ? CheckedOffset : UncheckedOffset;
 74 |                 ChangeCheckStates(false);
 75 |             }
 76 |         }
 77 | 
 78 |         protected override void OnDragCompleted(object sender, DragCompletedEventArgs e)
 79 |         {
 80 |             IsDragging = false;
 81 |             bool click = false;
 82 | 
 83 |             if ((!IsChecked && DragOffset < ((SwitchRoot.ActualHeight - SwitchThumb.ActualHeight) * (1.0 - Elasticity)))
 84 |                  || (IsChecked && DragOffset > ((SwitchRoot.ActualHeight - SwitchThumb.ActualHeight) * Elasticity)))
 85 |             {
 86 |                 double edge = IsChecked ? CheckedOffset : UncheckedOffset;
 87 |                 if (Offset != edge)
 88 |                 {
 89 |                     click = true;
 90 |                 }
 91 |             }
 92 |             else if (DragOffset == CheckedOffset || DragOffset == UncheckedOffset)
 93 |             {
 94 |                 click = true;
 95 |             }
 96 |             else
 97 |             {
 98 |                 ChangeCheckStates(true);
 99 |             }
100 | 
101 |             if (click)
102 |             {
103 |                 OnClick();
104 |             }
105 | 
106 |             DragOffset = 0;
107 |         }
108 |     }
109 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Toggle Switch Control Library
2 | =====================
3 | The Toggle Switch Control Library creates highly customizable toggle switch controls for WPF ~~and Silverlight~~ apps.
4 | 
5 | ![Screenshot](https://yetilabs.org/toggleswitch/gallery.png)
6 | 
7 | Available as a [NuGet package](https://www.nuget.org/packages/ToggleSwitch).


--------------------------------------------------------------------------------
/WPF/Demo/App.xaml:
--------------------------------------------------------------------------------
 1 | <Application x:Class="Demo.App"
 2 |              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
 4 |              xmlns:Demo="clr-namespace:Demo"
 5 |              StartupUri="MainWindow.xaml">
 6 |     <Application.Resources>
 7 |         <ResourceDictionary>
 8 |             <ResourceDictionary.MergedDictionaries>
 9 |                 <ResourceDictionary Source="Assets/Styles.xaml"/>
10 |                 <ResourceDictionary Source="Assets/ToggleSwitchStyles.xaml"/>
11 |             </ResourceDictionary.MergedDictionaries>
12 |             <Demo:DemoViewModel x:Key="DemoViewModel"/>
13 |             <BooleanToVisibilityConverter x:Key="VisibilityConverter"/>
14 |         </ResourceDictionary>
15 |     </Application.Resources>
16 | </Application>
17 | 


--------------------------------------------------------------------------------
/WPF/Demo/App.xaml.cs:
--------------------------------------------------------------------------------
1 | using System.Windows;
2 | 
3 | namespace Demo
4 | {
5 |     public partial class App : Application
6 |     {
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/WPF/Demo/Assets/Brushes.xaml:
--------------------------------------------------------------------------------
 1 | <ResourceDictionary
 2 |      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
 3 |      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 4 | 
 5 |     <SolidColorBrush x:Key="TextBrush" Color="#FF505050" />
 6 |     <SolidColorBrush x:Key="BodyTextColorBrush" Color="#FF313131"/>
 7 |     <SolidColorBrush x:Key="DisabledWhiteColorBrush" Color="White" />
 8 |     <SolidColorBrush x:Key="PageOverlayBrush" Color="#7F000000"/>
 9 | 
10 |     <SolidColorBrush x:Key="SliderTrackBrush" Color="#FF9D9D9D" />
11 |     <SolidColorBrush x:Key="HoverHyperlinkBackgroundBrush" Color="#FFF8FBFF"/>
12 | 
13 |     <DropShadowEffect x:Key="DropShadowBrush" Direction="330" Opacity="0.3" ShadowDepth="0" BlurRadius="6"/>
14 | </ResourceDictionary>
15 | 
16 | 


--------------------------------------------------------------------------------
/WPF/Demo/Assets/Fonts.xaml:
--------------------------------------------------------------------------------
 1 | <ResourceDictionary
 2 |      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
 3 |      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
 4 |      xmlns:my="clr-namespace:System;assembly=mscorlib" >
 5 | 
 6 |     <FontFamily x:Key="HeaderFontFamily">Segoe UI, Lucida Sans Unicode, Verdana</FontFamily>
 7 |     <FontFamily x:Key="ContentFontFamily">Segoe UI, Lucida Sans Unicode, Verdana</FontFamily>
 8 |     <my:Double x:Key="NavigationFontSize">32</my:Double>
 9 | </ResourceDictionary>
10 | 


--------------------------------------------------------------------------------
/WPF/Demo/Assets/Styles.xaml:
--------------------------------------------------------------------------------
  1 | <ResourceDictionary
  2 |      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
  3 |      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
  4 |     xmlns:Controls="clr-namespace:Demo.Controls">
  5 | 
  6 |     <ResourceDictionary.MergedDictionaries>
  7 |         <ResourceDictionary Source="Brushes.xaml"/>
  8 |         <ResourceDictionary Source="Fonts.xaml"/>
  9 |     </ResourceDictionary.MergedDictionaries>
 10 | 
 11 |     <!-- ******MAIN PAGE STYLES****** -->
 12 |     <Style x:Key="LinkStyle" TargetType="RadioButton">
 13 |         <Setter Property="BorderThickness" Value="1"/>
 14 |         <Setter Property="BorderBrush" Value="#FF9D9492"/>
 15 |         <Setter Property="Foreground" Value="#FF595C64"/>
 16 |         <Setter Property="FontFamily" Value="{StaticResource HeaderFontFamily}"/>
 17 |         <Setter Property="FontSize" Value="{StaticResource NavigationFontSize}"/>
 18 |         <Setter Property="Cursor" Value="Hand"/>
 19 |         <Setter Property="Margin" Value="25,0"/>
 20 |         <Setter Property="VerticalContentAlignment" Value="Center"/>
 21 |         <Setter Property="HorizontalContentAlignment" Value="Center"/>
 22 |         <Setter Property="FontStretch" Value="Condensed"/>
 23 |         <Setter Property="FontWeight" Value="Light"/>
 24 |         <Setter Property="Template">
 25 |             <Setter.Value>
 26 |                 <ControlTemplate TargetType="RadioButton">
 27 |                     <Grid x:Name="ButtonGrid" Cursor="{TemplateBinding Cursor}">
 28 |                         <VisualStateManager.VisualStateGroups>
 29 |                             <VisualStateGroup x:Name="CommonStates">
 30 |                                 <VisualState x:Name="Normal"/>
 31 |                                 <VisualState x:Name="MouseOver"/>
 32 |                                 <VisualState x:Name="Pressed">
 33 |                                     <Storyboard>
 34 |                                         <DoubleAnimationUsingKeyFrames BeginTime="0" Duration="00:00:00.001" Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="(UIElement.Opacity)">
 35 |                                             <LinearDoubleKeyFrame KeyTime="0" Value="0.75"/>
 36 |                                         </DoubleAnimationUsingKeyFrames>
 37 |                                         <DoubleAnimationUsingKeyFrames BeginTime="0" Duration="00:00:00.001" Storyboard.TargetName="InteractiveBorder" Storyboard.TargetProperty="(UIElement.Opacity)">
 38 |                                             <LinearDoubleKeyFrame KeyTime="0" Value="0.25"/>
 39 |                                         </DoubleAnimationUsingKeyFrames>
 40 |                                     </Storyboard>
 41 |                                 </VisualState>
 42 |                                 <VisualState x:Name="Disabled">
 43 |                                     <Storyboard>
 44 |                                         <ObjectAnimationUsingKeyFrames Duration="0" Storyboard.TargetName="DisabledOverlay" Storyboard.TargetProperty="Visibility">
 45 |                                             <DiscreteObjectKeyFrame KeyTime="0">
 46 |                                                 <DiscreteObjectKeyFrame.Value>
 47 |                                                     <Visibility>Visible</Visibility>
 48 |                                                 </DiscreteObjectKeyFrame.Value>
 49 |                                             </DiscreteObjectKeyFrame>
 50 |                                         </ObjectAnimationUsingKeyFrames>
 51 |                                         <ObjectAnimationUsingKeyFrames BeginTime="0" Duration="00:00:00.001" Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="(FrameworkElement.HorizontalAlignment)">
 52 |                                             <DiscreteObjectKeyFrame KeyTime="0">
 53 |                                                 <DiscreteObjectKeyFrame.Value>
 54 |                                                     <HorizontalAlignment>Center</HorizontalAlignment>
 55 |                                                 </DiscreteObjectKeyFrame.Value>
 56 |                                             </DiscreteObjectKeyFrame>
 57 |                                         </ObjectAnimationUsingKeyFrames>
 58 |                                         <ObjectAnimationUsingKeyFrames BeginTime="0" Duration="00:00:00.001" Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="(FrameworkElement.VerticalAlignment)">
 59 |                                             <DiscreteObjectKeyFrame KeyTime="0">
 60 |                                                 <DiscreteObjectKeyFrame.Value>
 61 |                                                     <VerticalAlignment>Center</VerticalAlignment>
 62 |                                                 </DiscreteObjectKeyFrame.Value>
 63 |                                             </DiscreteObjectKeyFrame>
 64 |                                         </ObjectAnimationUsingKeyFrames>
 65 |                                         <DoubleAnimationUsingKeyFrames BeginTime="0" Duration="00:00:00.001" Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="(UIElement.Opacity)">
 66 |                                             <LinearDoubleKeyFrame KeyTime="0" Value="0"/>
 67 |                                         </DoubleAnimationUsingKeyFrames>
 68 |                                         <DoubleAnimationUsingKeyFrames BeginTime="0" Duration="00:00:00.001" Storyboard.TargetName="DisabledOverlay" Storyboard.TargetProperty="(UIElement.Opacity)">
 69 |                                             <LinearDoubleKeyFrame KeyTime="0" Value="0.5"/>
 70 |                                         </DoubleAnimationUsingKeyFrames>
 71 |                                     </Storyboard>
 72 |                                 </VisualState>
 73 |                             </VisualStateGroup>
 74 |                             <VisualStateGroup x:Name="FocusStates">
 75 |                                 <VisualState x:Name="Unfocused"/>
 76 |                                 <VisualState x:Name="Focused"/>
 77 |                             </VisualStateGroup>
 78 |                             <VisualStateGroup x:Name="CheckStates">
 79 |                                 <VisualState x:Name="Checked"/>
 80 |                                 <VisualState x:Name="Unchecked">
 81 |                                     <Storyboard>
 82 |                                         <DoubleAnimation Duration="0" To="0" Storyboard.TargetProperty="(UIElement.Opacity)" Storyboard.TargetName="ContentBorder"/>
 83 |                                     </Storyboard>
 84 |                                 </VisualState>
 85 |                                 <VisualState x:Name="Indeterminate"/>
 86 |                             </VisualStateGroup>
 87 |                         </VisualStateManager.VisualStateGroups>
 88 |                         <Border x:Name="InteractiveBorder" MinWidth="{TemplateBinding MinWidth}" MinHeight="{TemplateBinding MinHeight}" Background="{StaticResource HoverHyperlinkBackgroundBrush}" BorderThickness="1,1,1,1" Opacity="0" BorderBrush="{StaticResource HoverHyperlinkBackgroundBrush}" CornerRadius="0"/>
 89 |                         <ContentPresenter x:Name="ContentPresenter" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" Margin="{TemplateBinding Padding}" Content="{TemplateBinding Content}" ContentTemplate="{TemplateBinding ContentTemplate}" />
 90 |                         <Border x:Name="ContentBorder" MinWidth="{TemplateBinding MinWidth}" MinHeight="{TemplateBinding MinHeight}" BorderThickness="0,0,0,1" BorderBrush="{TemplateBinding Foreground}"/>
 91 |                         <TextBlock x:Name="DisabledOverlay" Text="{TemplateBinding Content}" Foreground="#FFAAAAAA" Visibility="Collapsed" IsHitTestVisible="False" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" Margin="{TemplateBinding Padding}"/>
 92 |                     </Grid>
 93 |                 </ControlTemplate>
 94 |             </Setter.Value>
 95 |         </Setter>
 96 |     </Style>
 97 | 
 98 |     <!--CheckBox Style-->
 99 |     <Style TargetType="{x:Type CheckBox}" x:Key="DefaultCheckBoxStyle">
100 |         <Setter Property="FontFamily" Value="{StaticResource ContentFontFamily}"/>
101 |         <Setter Property="Foreground" Value="{StaticResource BodyTextColorBrush}"/>
102 |         <Setter Property="HorizontalAlignment" Value="Left"/>
103 |         <Setter Property="HorizontalContentAlignment" Value="Left"/>
104 |         <Setter Property="VerticalContentAlignment" Value="Center"/>
105 |         <Setter Property="Padding" Value="4,0,0,0"/>
106 |         <Setter Property="BorderThickness" Value="1"/>
107 |         <Setter Property="BorderBrush" Value="#FF7F7F7F"/>
108 |         <Setter Property="Background">
109 |             <Setter.Value>
110 |                 <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
111 |                     <GradientStop Color="#FFE5E5E5" Offset="0"/>
112 |                     <GradientStop Color="White" Offset="1"/>
113 |                 </LinearGradientBrush>
114 |             </Setter.Value>
115 |         </Setter>
116 |     </Style>
117 | 
118 |     <Style TargetType="{x:Type Controls:DropShadowTextBlock}">
119 |         <Setter Property="Text" Value="DropShadowTextBlock" />
120 |         <Setter Property="DropShadowColor" Value="Black" />
121 |         <Setter Property="DropShadowOpacity" Value="0.5" />
122 |         <Setter Property="DropShadowAngle" Value="45" />
123 |         <Setter Property="DropShadowDistance" Value="2" />
124 |         <Setter Property="Foreground" Value="Black" />
125 |         <Setter Property="Template">
126 |             <Setter.Value>
127 |                 <ControlTemplate TargetType="{x:Type Controls:DropShadowTextBlock}">
128 |                     <Grid Background="{TemplateBinding Background}" HorizontalAlignment="{TemplateBinding HorizontalAlignment}" VerticalAlignment="{TemplateBinding VerticalAlignment}">
129 |                         <TextBlock Text="{TemplateBinding Text}"
130 |                                               TextDecorations="{TemplateBinding TextDecorations}"
131 |                                               TextWrapping="{TemplateBinding TextWrapping}"
132 |                                               IsHitTestVisible="False">
133 |                                      <TextBlock.Foreground>
134 |                                           <SolidColorBrush x:Name="PART_DropShadowBrush" />
135 |                                      </TextBlock.Foreground>
136 |                                      <TextBlock.RenderTransform>
137 |                                           <TranslateTransform X="2" Y="2" x:Name="PART_DropShadowTranslate" />
138 |                                      </TextBlock.RenderTransform>
139 |                         </TextBlock>
140 |                         <TextBlock Text="{TemplateBinding Text}"
141 |                                       TextDecorations="{TemplateBinding TextDecorations}"
142 |                                       TextWrapping="{TemplateBinding TextWrapping}"/>
143 |                     </Grid>
144 |                 </ControlTemplate>
145 |             </Setter.Value>
146 |         </Setter>
147 |     </Style>
148 | 
149 |     <!-- Implicit Styles -->
150 |     <Style TargetType="{x:Type CheckBox}" BasedOn="{StaticResource DefaultCheckBoxStyle}" />
151 |     <LinearGradientBrush x:Key="HorizontalSliderThumbHoverBackgroundInverted" EndPoint="0,0" StartPoint="0,1">
152 |         <GradientStop Color="white" Offset="0"/>
153 |         <GradientStop Color="#B8E2F9" Offset="0.5"/>
154 |         <GradientStop Color="#B0DFF8" Offset="1"/>
155 |     </LinearGradientBrush>
156 |     <SolidColorBrush x:Key="HorizontalSliderThumbHoverBorder" Color="#3C7FB1"/>
157 |     <LinearGradientBrush x:Key="HorizontalSliderThumbPressedBackgroundInverted" EndPoint="0,0" StartPoint="0,1">
158 |         <GradientStop Color="#B8E4FA" Offset="0.25"/>
159 |         <GradientStop Color="#5EB4E3" Offset="0.5"/>
160 |         <GradientStop Color="#4C8BB4" Offset="1"/>
161 |     </LinearGradientBrush>
162 |     <SolidColorBrush x:Key="HorizontalSliderThumbPressedBorder" Color="#2C628B"/>
163 |     <Geometry x:Key="SliderThumbDisabledGeometry">M -5,-10.5 L 5,-10.5 L 5,10.5 L -5,10.5 Z</Geometry>
164 |     <Geometry x:Key="SliderPointedThumbDisabledGeometry">M 4.5,-8.5 L -4.5,-8.5 L -4.5,4.5 L -0.5,8.5 L 0.5,8.5 L 4.5,4.5 Z</Geometry>
165 |     <Geometry x:Key="SliderPointedThumbOuterBorderGeometry">M 4.5,-7.5 A 1 1 0 0 0 3.5,-8.5 L -3.5,-8.5 A 1 1 0 0 0 -4.5,-7.5 L -4.5,4.5 L -0.5,8.5 L 0.5,8.5 L 4.5,4.5 Z</Geometry>
166 |     <LinearGradientBrush x:Key="HorizontalSliderThumbNormalBackgroundInverted" EndPoint="0,0" StartPoint="0,1">
167 |         <GradientStop Color="White" Offset="0"/>
168 |         <GradientStop Color="#F0EFEF" Offset="0.4"/>
169 |         <GradientStop Color="#D6D5D5" Offset=".8"/>
170 |     </LinearGradientBrush>
171 |     <Geometry x:Key="SliderPointedThumbMiddleBorderGeometry">M 3.5,-7.5 L -3.5,-7.5 L -3.5,4.5 L 0,8 L 3.5,4.5 Z</Geometry>
172 |     <Style x:Key="HorizontalSliderUpThumbStyle" TargetType="{x:Type Thumb}">
173 |         <Setter Property="Focusable" Value="false"/>
174 |         <Setter Property="OverridesDefaultStyle" Value="true"/>
175 |         <Setter Property="Height" Value="18"/>
176 |         <Setter Property="Width" Value="10"/>
177 |         <Setter Property="Foreground" Value="Gray"/>
178 |         <Setter Property="Template">
179 |             <Setter.Value>
180 |                 <ControlTemplate TargetType="{x:Type Thumb}">
181 |                     <Canvas SnapsToDevicePixels="true">
182 |                         <Canvas.RenderTransform>
183 |                             <TransformGroup>
184 |                                 <TransformGroup.Children>
185 |                                     <TransformCollection>
186 |                                         <RotateTransform Angle="180"/>
187 |                                         <TranslateTransform X="5" Y="9"/>
188 |                                     </TransformCollection>
189 |                                 </TransformGroup.Children>
190 |                             </TransformGroup>
191 |                         </Canvas.RenderTransform>
192 |                         <Path x:Name="Background" Data="{StaticResource SliderPointedThumbOuterBorderGeometry}" Fill="{StaticResource HorizontalSliderThumbNormalBackgroundInverted}"/>
193 |                         <Path x:Name="InnerBorder" Data="{StaticResource SliderPointedThumbMiddleBorderGeometry}" Stroke="White" StrokeThickness="1"/>
194 |                         <Path x:Name="OuterBorder" Data="{StaticResource SliderPointedThumbOuterBorderGeometry}" Stroke="#FF929292" StrokeThickness="1"/>
195 |                     </Canvas>
196 |                     <ControlTemplate.Triggers>
197 |                         <Trigger Property="IsMouseOver" Value="true">
198 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource HorizontalSliderThumbHoverBackgroundInverted}"/>
199 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
200 |                         </Trigger>
201 |                         <Trigger Property="Foreground" Value="Blue">
202 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource HorizontalSliderThumbHoverBackgroundInverted}"/>
203 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
204 |                         </Trigger>
205 |                         <Trigger Property="IsDragging" Value="true">
206 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource HorizontalSliderThumbPressedBackgroundInverted}"/>
207 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbPressedBorder}"/>
208 |                         </Trigger>
209 |                         <Trigger Property="IsEnabled" Value="false">
210 |                             <Setter Property="Fill" TargetName="Background" Value="#FFF4F4F4"/>
211 |                             <Setter Property="Stroke" TargetName="InnerBorder" Value="{x:Null}"/>
212 |                             <Setter Property="Data" TargetName="OuterBorder" Value="{StaticResource SliderThumbDisabledGeometry}"/>
213 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="#FFAEB1AF"/>
214 |                             <Setter Property="Data" TargetName="OuterBorder" Value="{StaticResource SliderPointedThumbDisabledGeometry}"/>
215 |                         </Trigger>
216 |                     </ControlTemplate.Triggers>
217 |                 </ControlTemplate>
218 |             </Setter.Value>
219 |         </Setter>
220 |     </Style>
221 |     <LinearGradientBrush x:Key="HorizontalSliderThumbHoverBackground" EndPoint="0,1" StartPoint="0,0">
222 |         <GradientStop Color="white" Offset="0"/>
223 |         <GradientStop Color="#B8E2F9" Offset="0.5"/>
224 |         <GradientStop Color="#B0DFF8" Offset="1"/>
225 |     </LinearGradientBrush>
226 |     <LinearGradientBrush x:Key="HorizontalSliderThumbPressedBackground" EndPoint="0,1" StartPoint="0,0">
227 |         <GradientStop Color="#B8E4FA" Offset="0.25"/>
228 |         <GradientStop Color="#5EB4E3" Offset="0.5"/>
229 |         <GradientStop Color="#4C8BB4" Offset="1"/>
230 |     </LinearGradientBrush>
231 |     <LinearGradientBrush x:Key="HorizontalSliderThumbNormalBackground" EndPoint="0,1" StartPoint="0,0">
232 |         <GradientStop Color="White" Offset="0"/>
233 |         <GradientStop Color="#F0EFEF" Offset="0.4"/>
234 |         <GradientStop Color="#D6D5D5" Offset=".8"/>
235 |     </LinearGradientBrush>
236 |     <Style x:Key="HorizontalSliderDownThumbStyle" TargetType="{x:Type Thumb}">
237 |         <Setter Property="Focusable" Value="false"/>
238 |         <Setter Property="OverridesDefaultStyle" Value="true"/>
239 |         <Setter Property="Height" Value="18"/>
240 |         <Setter Property="Width" Value="10"/>
241 |         <Setter Property="Foreground" Value="Gray"/>
242 |         <Setter Property="Template">
243 |             <Setter.Value>
244 |                 <ControlTemplate TargetType="{x:Type Thumb}">
245 |                     <Canvas SnapsToDevicePixels="true">
246 |                         <Canvas.RenderTransform>
247 |                             <TranslateTransform X="5" Y="9"/>
248 |                         </Canvas.RenderTransform>
249 |                         <Path x:Name="Background" Data="{StaticResource SliderPointedThumbOuterBorderGeometry}" Fill="{StaticResource HorizontalSliderThumbNormalBackground}"/>
250 |                         <Path x:Name="InnerBorder" Data="{StaticResource SliderPointedThumbMiddleBorderGeometry}" Stroke="White" StrokeThickness="1"/>
251 |                         <Path x:Name="OuterBorder" Data="{StaticResource SliderPointedThumbOuterBorderGeometry}" Stroke="#FF929292" StrokeThickness="1"/>
252 |                     </Canvas>
253 |                     <ControlTemplate.Triggers>
254 |                         <Trigger Property="IsMouseOver" Value="true">
255 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource HorizontalSliderThumbHoverBackground}"/>
256 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
257 |                         </Trigger>
258 |                         <Trigger Property="Foreground" Value="Blue">
259 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource HorizontalSliderThumbHoverBackground}"/>
260 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
261 |                         </Trigger>
262 |                         <Trigger Property="IsDragging" Value="true">
263 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource HorizontalSliderThumbPressedBackground}"/>
264 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbPressedBorder}"/>
265 |                         </Trigger>
266 |                         <Trigger Property="IsEnabled" Value="false">
267 |                             <Setter Property="Fill" TargetName="Background" Value="#FFF4F4F4"/>
268 |                             <Setter Property="Stroke" TargetName="InnerBorder" Value="{x:Null}"/>
269 |                             <Setter Property="Data" TargetName="OuterBorder" Value="{StaticResource SliderThumbDisabledGeometry}"/>
270 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="#FFAEB1AF"/>
271 |                             <Setter Property="Data" TargetName="OuterBorder" Value="{StaticResource SliderPointedThumbDisabledGeometry}"/>
272 |                         </Trigger>
273 |                     </ControlTemplate.Triggers>
274 |                 </ControlTemplate>
275 |             </Setter.Value>
276 |         </Setter>
277 |     </Style>
278 |     <SolidColorBrush x:Key="HorizontalSliderTrackNormalBackground" Color="#FFE7EAEA"/>
279 |     <Style x:Key="SliderRepeatButtonStyle" TargetType="{x:Type RepeatButton}">
280 |         <Setter Property="OverridesDefaultStyle" Value="true"/>
281 |         <Setter Property="IsTabStop" Value="false"/>
282 |         <Setter Property="Focusable" Value="false"/>
283 |         <Setter Property="Template">
284 |             <Setter.Value>
285 |                 <ControlTemplate TargetType="{x:Type RepeatButton}">
286 |                     <Rectangle Fill="Transparent"/>
287 |                 </ControlTemplate>
288 |             </Setter.Value>
289 |         </Setter>
290 |     </Style>
291 |     <Geometry x:Key="SliderThumbOuterBorderGeometry">M -5,-9.5 A 1 1 0 0 1 -4,-10.5 L 4,-10.5 A 1 1 0 0 1 5,-9.5 L 5,9.5 A 1 1 0 0 1 4,10.5 L -4,10.5 A 1 1 0 0 1 -5,9.5 Z</Geometry>
292 |     <Geometry x:Key="SliderThumbMiddleBorderGeometry">M -4,-9.5 L 4,-9.5 L 4,9.5 L -4,9.5 Z</Geometry>
293 |     <Style x:Key="HorizontalSliderThumbStyle" TargetType="{x:Type Thumb}">
294 |         <Setter Property="Focusable" Value="false"/>
295 |         <Setter Property="OverridesDefaultStyle" Value="true"/>
296 |         <Setter Property="Height" Value="22"/>
297 |         <Setter Property="Width" Value="11"/>
298 |         <Setter Property="Foreground" Value="Gray"/>
299 |         <Setter Property="Template">
300 |             <Setter.Value>
301 |                 <ControlTemplate TargetType="{x:Type Thumb}">
302 |                     <Grid>
303 |                         <Rectangle Fill="{StaticResource HorizontalSliderThumbNormalBackground}" Width="8" Height="16" RadiusX="2" RadiusY="2" Stroke="{TemplateBinding BorderBrush}"/>
304 |                         <TextBlock Text="{Binding ToolTip, RelativeSource={RelativeSource TemplatedParent}, StringFormat={}{0:N1}}" VerticalAlignment="Bottom" Foreground="{StaticResource BodyTextColorBrush}" IsHitTestVisible="False" HorizontalAlignment="Right" Width="18" Margin="0,0,-1,0"/>
305 |                     </Grid>
306 |                     <ControlTemplate.Triggers>
307 |                         <Trigger Property="IsMouseOver" Value="true"/>
308 |                         <Trigger Property="Foreground" Value="Blue"/>
309 |                         <Trigger Property="IsDragging" Value="true"/>
310 |                         <Trigger Property="IsEnabled" Value="false"/>
311 |                     </ControlTemplate.Triggers>
312 |                 </ControlTemplate>
313 |             </Setter.Value>
314 |         </Setter>
315 |     </Style>
316 |     <LinearGradientBrush x:Key="VerticalSliderThumbHoverBackground" EndPoint="1,0" StartPoint="0,0">
317 |         <GradientStop Color="white" Offset="0"/>
318 |         <GradientStop Color="#B8E2F9" Offset="0.5"/>
319 |         <GradientStop Color="#B0DFF8" Offset="1"/>
320 |     </LinearGradientBrush>
321 |     <LinearGradientBrush x:Key="VerticalSliderThumbPressedBackground" EndPoint="1,0" StartPoint="0,0">
322 |         <GradientStop Color="#B8E4FA" Offset="0.25"/>
323 |         <GradientStop Color="#5EB4E3" Offset="0.5"/>
324 |         <GradientStop Color="#4C8BB4" Offset="1"/>
325 |     </LinearGradientBrush>
326 |     <LinearGradientBrush x:Key="VerticalSliderThumbNormalBackground" EndPoint="1,0" StartPoint="0,0">
327 |         <GradientStop Color="White" Offset="0"/>
328 |         <GradientStop Color="#F0EFEF" Offset="0.4"/>
329 |         <GradientStop Color="#D6D5D5" Offset=".8"/>
330 |     </LinearGradientBrush>
331 |     <Style x:Key="VerticalSliderLeftThumbStyle" TargetType="{x:Type Thumb}">
332 |         <Setter Property="Focusable" Value="false"/>
333 |         <Setter Property="OverridesDefaultStyle" Value="true"/>
334 |         <Setter Property="Height" Value="10"/>
335 |         <Setter Property="Width" Value="18"/>
336 |         <Setter Property="Foreground" Value="Gray"/>
337 |         <Setter Property="Template">
338 |             <Setter.Value>
339 |                 <ControlTemplate TargetType="{x:Type Thumb}">
340 |                     <Canvas SnapsToDevicePixels="true">
341 |                         <Canvas.RenderTransform>
342 |                             <TransformGroup>
343 |                                 <TransformGroup.Children>
344 |                                     <TransformCollection>
345 |                                         <RotateTransform Angle="90"/>
346 |                                         <TranslateTransform X="9" Y="5"/>
347 |                                     </TransformCollection>
348 |                                 </TransformGroup.Children>
349 |                             </TransformGroup>
350 |                         </Canvas.RenderTransform>
351 |                         <Path x:Name="Background" Data="{StaticResource SliderPointedThumbOuterBorderGeometry}" Fill="{StaticResource VerticalSliderThumbNormalBackground}"/>
352 |                         <Path x:Name="InnerBorder" Data="{StaticResource SliderPointedThumbMiddleBorderGeometry}" Stroke="White" StrokeThickness="1"/>
353 |                         <Path x:Name="OuterBorder" Data="{StaticResource SliderPointedThumbOuterBorderGeometry}" Stroke="#FF929292" StrokeThickness="1"/>
354 |                     </Canvas>
355 |                     <ControlTemplate.Triggers>
356 |                         <Trigger Property="IsMouseOver" Value="true">
357 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource VerticalSliderThumbHoverBackground}"/>
358 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
359 |                         </Trigger>
360 |                         <Trigger Property="Foreground" Value="Blue">
361 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource VerticalSliderThumbHoverBackground}"/>
362 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
363 |                         </Trigger>
364 |                         <Trigger Property="IsDragging" Value="true">
365 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource VerticalSliderThumbPressedBackground}"/>
366 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbPressedBorder}"/>
367 |                         </Trigger>
368 |                         <Trigger Property="IsEnabled" Value="false">
369 |                             <Setter Property="Fill" TargetName="Background" Value="#FFF4F4F4"/>
370 |                             <Setter Property="Stroke" TargetName="InnerBorder" Value="{x:Null}"/>
371 |                             <Setter Property="Data" TargetName="OuterBorder" Value="{StaticResource SliderPointedThumbDisabledGeometry}"/>
372 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="#FFAEB1AF"/>
373 |                         </Trigger>
374 |                     </ControlTemplate.Triggers>
375 |                 </ControlTemplate>
376 |             </Setter.Value>
377 |         </Setter>
378 |     </Style>
379 |     <LinearGradientBrush x:Key="VerticalSliderThumbHoverBackgroundInverted" EndPoint="0,0" StartPoint="1,0">
380 |         <GradientStop Color="white" Offset="0"/>
381 |         <GradientStop Color="#B8E2F9" Offset="0.5"/>
382 |         <GradientStop Color="#B0DFF8" Offset="1"/>
383 |     </LinearGradientBrush>
384 |     <LinearGradientBrush x:Key="VerticalSliderThumbPressedBackgroundInverted" EndPoint="0,0" StartPoint="1,0">
385 |         <GradientStop Color="#B8E4FA" Offset="0.25"/>
386 |         <GradientStop Color="#5EB4E3" Offset="0.5"/>
387 |         <GradientStop Color="#4C8BB4" Offset="1"/>
388 |     </LinearGradientBrush>
389 |     <LinearGradientBrush x:Key="VerticalSliderThumbNormalBackgroundInverted" EndPoint="0,0" StartPoint="1,0">
390 |         <GradientStop Color="White" Offset="0"/>
391 |         <GradientStop Color="#F0EFEF" Offset="0.4"/>
392 |         <GradientStop Color="#D6D5D5" Offset=".8"/>
393 |     </LinearGradientBrush>
394 |     <Style x:Key="VerticalSliderRightThumbStyle" TargetType="{x:Type Thumb}">
395 |         <Setter Property="Focusable" Value="false"/>
396 |         <Setter Property="OverridesDefaultStyle" Value="true"/>
397 |         <Setter Property="Height" Value="10"/>
398 |         <Setter Property="Width" Value="18"/>
399 |         <Setter Property="Foreground" Value="Gray"/>
400 |         <Setter Property="Template">
401 |             <Setter.Value>
402 |                 <ControlTemplate TargetType="{x:Type Thumb}">
403 |                     <Canvas SnapsToDevicePixels="true">
404 |                         <Canvas.RenderTransform>
405 |                             <TransformGroup>
406 |                                 <TransformGroup.Children>
407 |                                     <TransformCollection>
408 |                                         <RotateTransform Angle="-90"/>
409 |                                         <TranslateTransform X="9" Y="5"/>
410 |                                     </TransformCollection>
411 |                                 </TransformGroup.Children>
412 |                             </TransformGroup>
413 |                         </Canvas.RenderTransform>
414 |                         <Path x:Name="Background" Data="{StaticResource SliderPointedThumbOuterBorderGeometry}" Fill="{StaticResource VerticalSliderThumbNormalBackgroundInverted}"/>
415 |                         <Path x:Name="InnerBorder" Data="{StaticResource SliderPointedThumbMiddleBorderGeometry}" Stroke="White" StrokeThickness="1"/>
416 |                         <Path x:Name="OuterBorder" Data="{StaticResource SliderPointedThumbOuterBorderGeometry}" Stroke="#FF929292" StrokeThickness="1"/>
417 |                     </Canvas>
418 |                     <ControlTemplate.Triggers>
419 |                         <Trigger Property="IsMouseOver" Value="true">
420 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource VerticalSliderThumbHoverBackgroundInverted}"/>
421 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
422 |                         </Trigger>
423 |                         <Trigger Property="Foreground" Value="Blue">
424 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource VerticalSliderThumbHoverBackgroundInverted}"/>
425 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
426 |                         </Trigger>
427 |                         <Trigger Property="IsDragging" Value="true">
428 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource VerticalSliderThumbPressedBackgroundInverted}"/>
429 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbPressedBorder}"/>
430 |                         </Trigger>
431 |                         <Trigger Property="IsEnabled" Value="false">
432 |                             <Setter Property="Fill" TargetName="Background" Value="#FFF4F4F4"/>
433 |                             <Setter Property="Stroke" TargetName="InnerBorder" Value="{x:Null}"/>
434 |                             <Setter Property="Data" TargetName="OuterBorder" Value="{StaticResource SliderPointedThumbDisabledGeometry}"/>
435 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="#FFAEB1AF"/>
436 |                         </Trigger>
437 |                     </ControlTemplate.Triggers>
438 |                 </ControlTemplate>
439 |             </Setter.Value>
440 |         </Setter>
441 |     </Style>
442 |     <LinearGradientBrush x:Key="VerticalSliderTrackNormalBorder" EndPoint="1,0" StartPoint="0,0">
443 |         <GradientStop Color="#FFAEB1AF" Offset="0.1"/>
444 |         <GradientStop Color="White" Offset=".9"/>
445 |     </LinearGradientBrush>
446 |     <Style x:Key="VerticalSliderThumbStyle" TargetType="{x:Type Thumb}">
447 |         <Setter Property="Focusable" Value="false"/>
448 |         <Setter Property="OverridesDefaultStyle" Value="true"/>
449 |         <Setter Property="Height" Value="11"/>
450 |         <Setter Property="Width" Value="22"/>
451 |         <Setter Property="Foreground" Value="Gray"/>
452 |         <Setter Property="Template">
453 |             <Setter.Value>
454 |                 <ControlTemplate TargetType="{x:Type Thumb}">
455 |                     <Canvas SnapsToDevicePixels="true">
456 |                         <Canvas.RenderTransform>
457 |                             <TransformGroup>
458 |                                 <TransformGroup.Children>
459 |                                     <TransformCollection>
460 |                                         <RotateTransform Angle="90"/>
461 |                                         <TranslateTransform X="11" Y="5.5"/>
462 |                                     </TransformCollection>
463 |                                 </TransformGroup.Children>
464 |                             </TransformGroup>
465 |                         </Canvas.RenderTransform>
466 |                         <Path x:Name="Background" Data="{StaticResource SliderThumbOuterBorderGeometry}" Fill="{StaticResource VerticalSliderThumbNormalBackground}"/>
467 |                         <Path x:Name="InnerBorder" Data="{StaticResource SliderThumbMiddleBorderGeometry}" Stroke="White" StrokeThickness="1"/>
468 |                         <Path x:Name="OuterBorder" Data="{StaticResource SliderThumbOuterBorderGeometry}" Stroke="#FF929292" StrokeThickness="1"/>
469 |                     </Canvas>
470 |                     <ControlTemplate.Triggers>
471 |                         <Trigger Property="IsMouseOver" Value="true">
472 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource VerticalSliderThumbHoverBackground}"/>
473 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
474 |                         </Trigger>
475 |                         <Trigger Property="Foreground" Value="Blue">
476 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource VerticalSliderThumbHoverBackground}"/>
477 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbHoverBorder}"/>
478 |                         </Trigger>
479 |                         <Trigger Property="IsDragging" Value="true">
480 |                             <Setter Property="Fill" TargetName="Background" Value="{StaticResource VerticalSliderThumbPressedBackground}"/>
481 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="{StaticResource HorizontalSliderThumbPressedBorder}"/>
482 |                         </Trigger>
483 |                         <Trigger Property="IsEnabled" Value="false">
484 |                             <Setter Property="Fill" TargetName="Background" Value="#FFF4F4F4"/>
485 |                             <Setter Property="Stroke" TargetName="InnerBorder" Value="{x:Null}"/>
486 |                             <Setter Property="Data" TargetName="OuterBorder" Value="{StaticResource SliderThumbDisabledGeometry}"/>
487 |                             <Setter Property="Stroke" TargetName="OuterBorder" Value="#FFAEB1AF"/>
488 |                         </Trigger>
489 |                     </ControlTemplate.Triggers>
490 |                 </ControlTemplate>
491 |             </Setter.Value>
492 |         </Setter>
493 |     </Style>
494 |     <Style x:Key="SliderStyle" TargetType="{x:Type Slider}">
495 |         <Setter Property="Stylus.IsPressAndHoldEnabled" Value="false"/>
496 |         <Setter Property="Background" Value="Transparent"/>
497 |         <Setter Property="Foreground" Value="#FFC4C4C4"/>
498 |         <Setter Property="Template">
499 |             <Setter.Value>
500 |                 <ControlTemplate TargetType="{x:Type Slider}">
501 |                     <Border BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" SnapsToDevicePixels="true">
502 |                         <Grid>
503 |                             <Grid.RowDefinitions>
504 |                                 <RowDefinition Height="Auto"/>
505 |                                 <RowDefinition Height="Auto" MinHeight="{TemplateBinding MinHeight}"/>
506 |                                 <RowDefinition Height="Auto"/>
507 |                             </Grid.RowDefinitions>
508 |                             <Border x:Name="TrackBackground" BorderThickness="1" Background="{DynamicResource SliderTrackBrush}" CornerRadius="1" Height="4.0" Margin="5,0" Grid.Row="1" VerticalAlignment="Center">
509 |                                 <Canvas Margin="-6,-1">
510 |                                     <Rectangle x:Name="PART_SelectionRange" Fill="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" Height="4.0" Stroke="{DynamicResource {x:Static SystemColors.ControlDarkDarkBrushKey}}" StrokeThickness="1.0" Visibility="Hidden"/>
511 |                                 </Canvas>
512 |                             </Border>
513 |                             <Track x:Name="PART_Track" Grid.Row="1">
514 |                                 <Track.DecreaseRepeatButton>
515 |                                     <RepeatButton Command="{x:Static Slider.DecreaseLarge}" Style="{StaticResource SliderRepeatButtonStyle}"/>
516 |                                 </Track.DecreaseRepeatButton>
517 |                                 <Track.IncreaseRepeatButton>
518 |                                     <RepeatButton Command="{x:Static Slider.IncreaseLarge}" Style="{StaticResource SliderRepeatButtonStyle}"/>
519 |                                 </Track.IncreaseRepeatButton>
520 |                                 <Track.Thumb>
521 |                                     <Thumb x:Name="Thumb" Style="{StaticResource HorizontalSliderThumbStyle}" BorderBrush="{StaticResource SliderTrackBrush}" BorderThickness="1" ToolTip="{Binding Value, RelativeSource={RelativeSource TemplatedParent}}" Height="45" Width="18"/>
522 |                                 </Track.Thumb>
523 |                             </Track>
524 |                         </Grid>
525 |                     </Border>
526 |                     <ControlTemplate.Triggers>
527 |                         <Trigger Property="TickPlacement" Value="TopLeft">
528 |                             <Setter Property="Style" TargetName="Thumb" Value="{StaticResource HorizontalSliderUpThumbStyle}"/>
529 |                             <Setter Property="Margin" TargetName="TrackBackground" Value="5,2,5,0"/>
530 |                         </Trigger>
531 |                         <Trigger Property="TickPlacement" Value="BottomRight">
532 |                             <Setter Property="Style" TargetName="Thumb" Value="{StaticResource HorizontalSliderDownThumbStyle}"/>
533 |                             <Setter Property="Margin" TargetName="TrackBackground" Value="5,0,5,2"/>
534 |                         </Trigger>
535 |                         <Trigger Property="TickPlacement" Value="Both"/>
536 |                         <Trigger Property="IsSelectionRangeEnabled" Value="true">
537 |                             <Setter Property="Visibility" TargetName="PART_SelectionRange" Value="Visible"/>
538 |                         </Trigger>
539 |                         <Trigger Property="IsKeyboardFocused" Value="true">
540 |                             <Setter Property="Foreground" TargetName="Thumb" Value="Blue"/>
541 |                         </Trigger>
542 |                     </ControlTemplate.Triggers>
543 |                 </ControlTemplate>
544 |             </Setter.Value>
545 |         </Setter>
546 |         <Style.Triggers>
547 |             <Trigger Property="Orientation" Value="Vertical">
548 |                 <Setter Property="Template">
549 |                     <Setter.Value>
550 |                         <ControlTemplate TargetType="{x:Type Slider}">
551 |                             <Border BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" SnapsToDevicePixels="true">
552 |                                 <Grid>
553 |                                     <Grid.ColumnDefinitions>
554 |                                         <ColumnDefinition Width="Auto"/>
555 |                                         <ColumnDefinition MinWidth="{TemplateBinding MinWidth}" Width="Auto"/>
556 |                                         <ColumnDefinition Width="Auto"/>
557 |                                     </Grid.ColumnDefinitions>
558 |                                     <TickBar x:Name="TopTick" Grid.Column="0" Fill="{TemplateBinding Foreground}" Placement="Left" Visibility="Collapsed" Width="4"/>
559 |                                     <TickBar x:Name="BottomTick" Grid.Column="2" Fill="{TemplateBinding Foreground}" Placement="Right" Visibility="Collapsed" Width="4"/>
560 |                                     <Border x:Name="TrackBackground" BorderBrush="{StaticResource VerticalSliderTrackNormalBorder}" BorderThickness="1" Background="{StaticResource HorizontalSliderTrackNormalBackground}" Grid.Column="1" CornerRadius="1" HorizontalAlignment="center" Margin="0,5" Width="4.0">
561 |                                         <Canvas Margin="-1,-6">
562 |                                             <Rectangle x:Name="PART_SelectionRange" Fill="{DynamicResource {x:Static SystemColors.HighlightBrushKey}}" Stroke="{DynamicResource {x:Static SystemColors.ControlDarkDarkBrushKey}}" StrokeThickness="1.0" Visibility="Hidden" Width="4.0"/>
563 |                                         </Canvas>
564 |                                     </Border>
565 |                                     <Track x:Name="PART_Track" Grid.Column="1">
566 |                                         <Track.DecreaseRepeatButton>
567 |                                             <RepeatButton Command="{x:Static Slider.DecreaseLarge}" Style="{StaticResource SliderRepeatButtonStyle}"/>
568 |                                         </Track.DecreaseRepeatButton>
569 |                                         <Track.IncreaseRepeatButton>
570 |                                             <RepeatButton Command="{x:Static Slider.IncreaseLarge}" Style="{StaticResource SliderRepeatButtonStyle}"/>
571 |                                         </Track.IncreaseRepeatButton>
572 |                                         <Track.Thumb>
573 |                                             <Thumb x:Name="Thumb" Style="{StaticResource VerticalSliderThumbStyle}"/>
574 |                                         </Track.Thumb>
575 |                                     </Track>
576 |                                 </Grid>
577 |                             </Border>
578 |                             <ControlTemplate.Triggers>
579 |                                 <Trigger Property="TickPlacement" Value="TopLeft">
580 |                                     <Setter Property="Visibility" TargetName="TopTick" Value="Visible"/>
581 |                                     <Setter Property="Style" TargetName="Thumb" Value="{StaticResource VerticalSliderLeftThumbStyle}"/>
582 |                                     <Setter Property="Margin" TargetName="TrackBackground" Value="2,5,0,5"/>
583 |                                 </Trigger>
584 |                                 <Trigger Property="TickPlacement" Value="BottomRight">
585 |                                     <Setter Property="Visibility" TargetName="BottomTick" Value="Visible"/>
586 |                                     <Setter Property="Style" TargetName="Thumb" Value="{StaticResource VerticalSliderRightThumbStyle}"/>
587 |                                     <Setter Property="Margin" TargetName="TrackBackground" Value="0,5,2,5"/>
588 |                                 </Trigger>
589 |                                 <Trigger Property="TickPlacement" Value="Both">
590 |                                     <Setter Property="Visibility" TargetName="TopTick" Value="Visible"/>
591 |                                     <Setter Property="Visibility" TargetName="BottomTick" Value="Visible"/>
592 |                                 </Trigger>
593 |                                 <Trigger Property="IsSelectionRangeEnabled" Value="true">
594 |                                     <Setter Property="Visibility" TargetName="PART_SelectionRange" Value="Visible"/>
595 |                                 </Trigger>
596 |                                 <Trigger Property="IsKeyboardFocused" Value="true">
597 |                                     <Setter Property="Foreground" TargetName="Thumb" Value="Blue"/>
598 |                                 </Trigger>
599 |                             </ControlTemplate.Triggers>
600 |                         </ControlTemplate>
601 |                     </Setter.Value>
602 |                 </Setter>
603 |             </Trigger>
604 |         </Style.Triggers>
605 |     </Style>
606 | </ResourceDictionary>


--------------------------------------------------------------------------------
/WPF/Demo/Demo.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 2 | 
 3 |   <PropertyGroup>
 4 |     <OutputType>WinExe</OutputType>
 5 |     <TargetFrameworks>netcoreapp3.1</TargetFrameworks>
 6 |     <UseWPF>true</UseWPF>
 7 |   </PropertyGroup>
 8 |   <PropertyGroup>
 9 |     <AssemblyTitle>Toggle Switch Demo</AssemblyTitle>
10 |     <Product>Toggle Switch Demo</Product>
11 |     <Copyright>Copyright © Eric Jensen 2020</Copyright>
12 |     <AssemblyVersion>1.2.0.0</AssemblyVersion>
13 |     <FileVersion>1.2.0.0</FileVersion>
14 |     <PackageProjectUrl>https://github.com/ejensen/toggle-switch-control</PackageProjectUrl>
15 |     <RepositoryUrl>https://github.com/ejensen/toggle-switch-control</RepositoryUrl>
16 |     <Authors>Eric Jensen</Authors>
17 |     <Company>Yeti Labs</Company>
18 |     <StartupObject>Demo.App</StartupObject>
19 |     <Version>1.2.0</Version>
20 |     <PackageLicenseExpression>MIT</PackageLicenseExpression>
21 |     <RepositoryType>git</RepositoryType>
22 |   </PropertyGroup>
23 | 
24 |   <ItemGroup>
25 |     <ProjectReference Include="..\ToggleSwitch\ToggleSwitch.csproj" />
26 |   </ItemGroup>
27 |   <ItemGroup>
28 |     <Compile Include="..\..\Common\DropShadowTextBlock.cs">
29 |       <Link>Controls\DropShadowTextBlock.cs</Link>
30 |     </Compile>
31 |     <Compile Include="..\..\Common\Utils\CornerRadiusValueConverter.cs">
32 |       <Link>Utils\CornerRadiusValueConverter.cs</Link>
33 |     </Compile>
34 |     <Compile Include="..\..\Common\Utils\ScalarValueConverter.cs">
35 |       <Link>Utils\ScalarValueConverter.cs</Link>
36 |     </Compile>
37 |     <Compile Include="..\..\Common\VerticalToggleSwitch.cs">
38 |       <Link>Controls\VerticalToggleSwitch.cs</Link>
39 |     </Compile>
40 |   </ItemGroup>
41 | 
42 |   <ItemGroup>
43 |     <Resource Include="Images\Knob.png" />
44 |     <Resource Include="Images\lightOff.png" />
45 |     <Resource Include="Images\lightOn.png" />
46 |   </ItemGroup>
47 | </Project>


--------------------------------------------------------------------------------
/WPF/Demo/DemoViewModel.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.ComponentModel;
 3 | using System.Windows.Threading;
 4 | 
 5 | namespace Demo
 6 | {
 7 |     public class DemoViewModel : INotifyPropertyChanged
 8 |     {
 9 |         private readonly DispatcherTimer _restartEventTimer = new DispatcherTimer();
10 | 
11 |         public DemoViewModel()
12 |         {
13 |             _restartEventTimer.Interval = TimeSpan.FromSeconds(1.5);
14 |             _restartEventTimer.Tick += delegate { _restartEventTimer.Stop(); RestartToggleChecked = false; };
15 |         }
16 | 
17 |         private bool _restartToggleChecked;
18 |         public bool RestartToggleChecked
19 |         {
20 |             get
21 |             {
22 |                 return _restartToggleChecked;
23 |             }
24 |             set
25 |             {
26 |                 if (_restartToggleChecked != value)
27 |                 {
28 |                     _restartToggleChecked = value;
29 |                     InvokePropertyChanged("RestartToggleChecked");
30 | 
31 |                     if (_restartToggleChecked)
32 |                     {
33 |                         _restartEventTimer.Start();
34 |                     }
35 |                 }
36 |             }
37 |         }
38 | 
39 |         public event PropertyChangedEventHandler PropertyChanged;
40 |         public void InvokePropertyChanged(string propertyName)
41 |         {
42 |             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/WPF/Demo/Images/Knob.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ejensen/toggle-switch-control/1761c450de096c7cea7ec1d81f337ed7f9e69624/WPF/Demo/Images/Knob.png


--------------------------------------------------------------------------------
/WPF/Demo/Images/lightOff.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ejensen/toggle-switch-control/1761c450de096c7cea7ec1d81f337ed7f9e69624/WPF/Demo/Images/lightOff.png


--------------------------------------------------------------------------------
/WPF/Demo/Images/lightOn.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ejensen/toggle-switch-control/1761c450de096c7cea7ec1d81f337ed7f9e69624/WPF/Demo/Images/lightOn.png


--------------------------------------------------------------------------------
/WPF/Demo/MainWindow.xaml:
--------------------------------------------------------------------------------
 1 | <Window x:Class="Demo.MainWindow"
 2 |         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3 |         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
 4 |         xmlns:Demo="clr-namespace:Demo"
 5 |         Title="Toggle Switch Demo" 
 6 |         Height="320" 
 7 |         Width="680" 
 8 |         DataContext="{StaticResource DemoViewModel}"
 9 |         Background="#FFFAFAFA">
10 |     <Grid>
11 |         <Grid Margin="20">
12 |             <Grid.RowDefinitions>
13 |                 <RowDefinition Height="Auto"/>
14 |                 <RowDefinition Height="*"/>
15 |             </Grid.RowDefinitions>
16 | 
17 |             <StackPanel x:Name="LinksStackPanel" Orientation="Horizontal">
18 |                 <RadioButton Style="{StaticResource LinkStyle}" x:Name="Basics" Content="BASICS" Margin="0,0,20,0" IsChecked="True" />
19 |                 <RadioButton Style="{StaticResource LinkStyle}" x:Name="Styling" Content="STYLING"/>
20 |                 <RadioButton Style="{StaticResource LinkStyle}" x:Name="Events" Content="EVENTS"/>
21 |                 <RadioButton Style="{StaticResource LinkStyle}" x:Name="Extending" Content="EXTENDING" Margin="20,0,0,0"/>
22 |             </StackPanel>
23 |             <Grid Grid.Row="1" Margin="0,20,0,0">
24 |                 <Demo:Basics Visibility="{Binding ElementName=Basics, Path=IsChecked, Converter={StaticResource VisibilityConverter}}"/>
25 |                 <Demo:Styling Visibility="{Binding ElementName=Styling, Path=IsChecked, Converter={StaticResource VisibilityConverter}}"/>
26 |                 <Demo:Events Visibility="{Binding ElementName=Events, Path=IsChecked, Converter={StaticResource VisibilityConverter}}"/>
27 |                 <Demo:Extending Visibility="{Binding ElementName=Extending, Path=IsChecked, Converter={StaticResource VisibilityConverter}}"/>
28 |             </Grid>
29 |         </Grid>
30 |     </Grid>
31 | </Window>
32 | 


--------------------------------------------------------------------------------
/WPF/Demo/MainWindow.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows;
 2 | 
 3 | namespace Demo
 4 | {
 5 |     public partial class MainWindow : Window
 6 |     {
 7 |         public MainWindow()
 8 |         {
 9 |             InitializeComponent();
10 |         }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/WPF/Demo/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Resources;
 3 | using System.Runtime.InteropServices;
 4 | using System.Windows;
 5 | 
 6 | // General Information about an assembly is controlled through the following 
 7 | // set of attributes. Change these attribute values to modify the information
 8 | // associated with an assembly.
 9 | [assembly: AssemblyTrademark("")]
10 | [assembly: AssemblyCulture("")]
11 | 
12 | // Setting ComVisible to false makes the types in this assembly not visible 
13 | // to COM components.  If you need to access a type in this assembly from 
14 | // COM, set the ComVisible attribute to true on that type.
15 | [assembly: ComVisible(false)]
16 | 
17 | //In order to begin building localizable applications, set 
18 | //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
19 | //inside a <PropertyGroup>.  For example, if you are using US english
20 | //in your source files, set the <UICulture> to en-US.  Then uncomment
21 | //the NeutralResourceLanguage attribute below.  Update the "en-US" in
22 | //the line below to match the UICulture setting in the project file.
23 | 
24 | //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
25 | 
26 | 
27 | [assembly: ThemeInfo(
28 |     ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
29 |                                      //(used if a resource is not found in the page, 
30 |                                      // or application resource dictionaries)
31 |     ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
32 |                                               //(used if a resource is not found in the page, 
33 |                                               // app, or any theme specific resource dictionaries)
34 | )]
35 | 
36 | 
37 | // Version information for an assembly consists of the following four values:
38 | //
39 | //      Major Version
40 | //      Minor Version 
41 | //      Build Number
42 | //      Revision
43 | //
44 | // You can specify all the values or you can default the Build and Revision Numbers 
45 | // by using the '*' as shown below:
46 | // [assembly: AssemblyVersion("1.0.*")]
47 | [assembly: NeutralResourcesLanguageAttribute("en")]
48 | 


--------------------------------------------------------------------------------
/WPF/Demo/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.225
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace Demo.Properties {
12 |     using System;
13 |     
14 |     
15 |     /// <summary>
16 |     ///   A strongly-typed resource class, for looking up localized strings, etc.
17 |     /// </summary>
18 |     // This class was auto-generated by the StronglyTypedResourceBuilder
19 |     // class via a tool like ResGen or Visual Studio.
20 |     // To add or remove a member, edit your .ResX file then rerun ResGen
21 |     // with the /str option, or rebuild your VS project.
22 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
23 |     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 |     internal class Resources {
26 |         
27 |         private static global::System.Resources.ResourceManager resourceMan;
28 |         
29 |         private static global::System.Globalization.CultureInfo resourceCulture;
30 |         
31 |         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
32 |         internal Resources() {
33 |         }
34 |         
35 |         /// <summary>
36 |         ///   Returns the cached ResourceManager instance used by this class.
37 |         /// </summary>
38 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
39 |         internal static global::System.Resources.ResourceManager ResourceManager {
40 |             get {
41 |                 if (object.ReferenceEquals(resourceMan, null)) {
42 |                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Demo.Properties.Resources", typeof(Resources).Assembly);
43 |                     resourceMan = temp;
44 |                 }
45 |                 return resourceMan;
46 |             }
47 |         }
48 |         
49 |         /// <summary>
50 |         ///   Overrides the current thread's CurrentUICulture property for all
51 |         ///   resource lookups using this strongly typed resource class.
52 |         /// </summary>
53 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
54 |         internal static global::System.Globalization.CultureInfo Culture {
55 |             get {
56 |                 return resourceCulture;
57 |             }
58 |             set {
59 |                 resourceCulture = value;
60 |             }
61 |         }
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/WPF/Demo/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:element name="root" msdata:IsDataSet="true">
 64 |       <xsd:complexType>
 65 |         <xsd:choice maxOccurs="unbounded">
 66 |           <xsd:element name="metadata">
 67 |             <xsd:complexType>
 68 |               <xsd:sequence>
 69 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 70 |               </xsd:sequence>
 71 |               <xsd:attribute name="name" type="xsd:string" />
 72 |               <xsd:attribute name="type" type="xsd:string" />
 73 |               <xsd:attribute name="mimetype" type="xsd:string" />
 74 |             </xsd:complexType>
 75 |           </xsd:element>
 76 |           <xsd:element name="assembly">
 77 |             <xsd:complexType>
 78 |               <xsd:attribute name="alias" type="xsd:string" />
 79 |               <xsd:attribute name="name" type="xsd:string" />
 80 |             </xsd:complexType>
 81 |           </xsd:element>
 82 |           <xsd:element name="data">
 83 |             <xsd:complexType>
 84 |               <xsd:sequence>
 85 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 86 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 87 |               </xsd:sequence>
 88 |               <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
 89 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 90 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 91 |             </xsd:complexType>
 92 |           </xsd:element>
 93 |           <xsd:element name="resheader">
 94 |             <xsd:complexType>
 95 |               <xsd:sequence>
 96 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 97 |               </xsd:sequence>
 98 |               <xsd:attribute name="name" type="xsd:string" use="required" />
 99 |             </xsd:complexType>
100 |           </xsd:element>
101 |         </xsd:choice>
102 |       </xsd:complexType>
103 |     </xsd:element>
104 |   </xsd:schema>
105 |   <resheader name="resmimetype">
106 |     <value>text/microsoft-resx</value>
107 |   </resheader>
108 |   <resheader name="version">
109 |     <value>2.0</value>
110 |   </resheader>
111 |   <resheader name="reader">
112 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
113 |   </resheader>
114 |   <resheader name="writer">
115 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 | </root>


--------------------------------------------------------------------------------
/WPF/Demo/Properties/Settings.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.225
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace Demo.Properties {
12 |     
13 |     
14 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
15 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")]
16 |     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
17 |         
18 |         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
19 |         
20 |         public static Settings Default {
21 |             get {
22 |                 return defaultInstance;
23 |             }
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/WPF/Demo/Properties/Settings.settings:
--------------------------------------------------------------------------------
1 | <?xml version='1.0' encoding='utf-8'?>
2 | <SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
3 |   <Profiles>
4 |     <Profile Name="(Default)" />
5 |   </Profiles>
6 |   <Settings />
7 | </SettingsFile>


--------------------------------------------------------------------------------
/WPF/Demo/Views/Basics.xaml:
--------------------------------------------------------------------------------
 1 | <UserControl 
 2 |      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
 3 |      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |      xmlns:ToggleSwitch="clr-namespace:ToggleSwitch;assembly=ToggleSwitch"
 5 |      x:Class="Demo.Basics">
 6 | 
 7 |     <Grid>
 8 |         <Grid.ColumnDefinitions>
 9 |             <ColumnDefinition Width="*"/>
10 |             <ColumnDefinition Width="Auto"/>
11 |             <ColumnDefinition Width="Auto"/>
12 |             <ColumnDefinition Width="Auto"/>
13 |         </Grid.ColumnDefinitions>
14 |         <Grid.RowDefinitions>
15 |             <RowDefinition Height="Auto"/>
16 |             <RowDefinition Height="Auto"/>
17 |             <RowDefinition Height="*"/>
18 |         </Grid.RowDefinitions>
19 |         <TextBlock Text="A toggle switch is similar to a toggle button, but provides more dynamic checked states." TextWrapping="Wrap" Margin="0,0,0,10" />
20 |         <ToggleSwitch:HorizontalToggleSwitch
21 |             Grid.Column="2"
22 |             IsChecked="True"
23 |             VerticalAlignment="Top"
24 |             Margin="0,0,0,10"
25 |             HorizontalAlignment="Left"/>
26 |         <TextBlock Text="The checked &amp; unchecked regions of a toggle switch are fully customizable." Grid.Row="1" Margin="0,10" TextWrapping="Wrap"/>
27 |         <ToggleSwitch:HorizontalToggleSwitch
28 |             Grid.Column="2"
29 |             Grid.Row="1" 
30 |             IsChecked="True"
31 |             Margin="0,10"
32 |             VerticalAlignment="Top"
33 |             HorizontalAlignment="Left" >
34 |             <ToggleSwitch:HorizontalToggleSwitch.UncheckedContent>
35 |                 <Grid>
36 |                     <Path Data="M0,0 L25,25" Stroke="White" Stretch="UniformToFill" StrokeThickness="6"/>
37 |                     <Path Data="M0,25 L25,0" Stroke="White" Stretch="UniformToFill" StrokeThickness="6" />
38 |                 </Grid>
39 |             </ToggleSwitch:HorizontalToggleSwitch.UncheckedContent>
40 |             <ToggleSwitch:HorizontalToggleSwitch.CheckedContent>
41 |                 <Path Fill="White" Stretch="UniformToFill" Data="M 21.7,52.2 L 74.4,0 L 74.4,18.667 L 22,70.708 L 0.,49 L 0,29.8 L 21.7,52.2 Z" />
42 |             </ToggleSwitch:HorizontalToggleSwitch.CheckedContent>
43 |         </ToggleSwitch:HorizontalToggleSwitch>
44 |         <TextBlock Text="Switch elasticity determines how far the switch needs to be dragged before it snaps to the opposite side." TextWrapping="Wrap" Grid.Row="2" Margin="0,10,0,0" />
45 |         <ToggleSwitch:HorizontalToggleSwitch
46 |             Elasticity="{Binding Value, ElementName=Slider}"
47 |             IsChecked="True"
48 |             VerticalAlignment="Top"
49 |             HorizontalAlignment="Left"
50 |             Margin="0,10,0,0"
51 |             Grid.Column="2"
52 |             Grid.Row="2" />
53 |         <Slider x:Name="Slider" Grid.Column="3" Grid.Row="2" Margin="10,0,0,0" Maximum="1" LargeChange="0.1" SmallChange="0.05" Value="0.5" Width="88" HorizontalAlignment="Left" Style="{DynamicResource SliderStyle}" />
54 |         <Line Stroke="#70595C64" Grid.Column="1" Grid.RowSpan="3" Y2="165" StrokeThickness="1" Margin="20,0" StrokeDashArray="1"/>
55 |     </Grid>
56 | </UserControl>
57 | 


--------------------------------------------------------------------------------
/WPF/Demo/Views/Basics.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows.Controls;
 2 | 
 3 | namespace Demo
 4 | {
 5 |     public partial class Basics : UserControl
 6 |     {
 7 |         public Basics()
 8 |         {
 9 |             InitializeComponent();
10 |         }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/WPF/Demo/Views/Events.xaml:
--------------------------------------------------------------------------------
 1 | <UserControl x:Class="Demo.Events" 
 2 |      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
 3 |      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
 4 |      xmlns:ToggleSwitch="clr-namespace:ToggleSwitch;assembly=ToggleSwitch">
 5 | 
 6 |     <Grid>
 7 |         <Grid.ColumnDefinitions>
 8 |             <ColumnDefinition Width="*"/>
 9 |             <ColumnDefinition Width="Auto"/>
10 |             <ColumnDefinition Width="Auto"/>
11 |         </Grid.ColumnDefinitions>
12 |         <Grid.RowDefinitions>
13 |             <RowDefinition Height="Auto"/>
14 |             <RowDefinition Height="Auto"/>
15 |         </Grid.RowDefinitions>
16 |         <TextBlock Text="Databinding to the IsChecked property enables programmatic control over the toggle switch." TextWrapping="Wrap" Margin="0,0,0,10"/>
17 |         <StackPanel Grid.Column="2" Orientation="Horizontal" VerticalAlignment="Top" Margin="0,0,0,10">
18 |             <ToggleSwitch:HorizontalToggleSwitch x:Name="HorizontalToggleSwitch" ThumbTemplate="{StaticResource GroovedThumbTemplate}" />
19 |             <CheckBox IsChecked="{Binding IsChecked, ElementName=HorizontalToggleSwitch, Mode=TwoWay}" Content="IsChecked" Margin="20,0,0,0" VerticalAlignment="Center" />
20 |         </StackPanel>
21 |         <TextBlock Text="Custom behavior can be created by responding to state-change events." Grid.Row="1" TextWrapping="Wrap" Margin="0,10,0,0"/>
22 |         <ToggleSwitch:HorizontalToggleSwitch
23 |             IsChecked="{Binding RestartToggleChecked, Mode=TwoWay}" Elasticity="0.75"
24 |             ThumbTemplate="{StaticResource RestartThumbTemplate}" 
25 |             CheckedContent="Restarting"
26 |             UncheckedContent="Online" Width="120" Grid.Row="1" Grid.Column="2" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="0,10,0,0" >
27 |             <ToggleSwitch:HorizontalToggleSwitch.CheckedBackground>
28 |                 <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
29 |                     <GradientStop Color="#FFC80000" Offset="1"/>
30 |                     <GradientStop Color="#FFB00000"/>
31 |                 </LinearGradientBrush>
32 |             </ToggleSwitch:HorizontalToggleSwitch.CheckedBackground>
33 |             <ToggleSwitch:HorizontalToggleSwitch.UncheckedBackground>
34 |                 <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
35 |                     <GradientStop Color="#FF5EAD09" Offset="1"/>
36 |                     <GradientStop Color="#FF478108"/>
37 |                 </LinearGradientBrush>
38 |             </ToggleSwitch:HorizontalToggleSwitch.UncheckedBackground>
39 |         </ToggleSwitch:HorizontalToggleSwitch>
40 |         <Line Stroke="#70595C64" Grid.Column="1" Grid.RowSpan="3" Y2="100" StrokeThickness="1" Margin="20,0" StrokeDashArray="1"/>
41 |     </Grid>
42 | </UserControl>


--------------------------------------------------------------------------------
/WPF/Demo/Views/Events.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows.Controls;
 2 | 
 3 | namespace Demo
 4 | {
 5 |     public partial class Events : UserControl
 6 |     {
 7 |         public Events()
 8 |         {
 9 |             InitializeComponent();
10 |         }
11 |     }
12 | }


--------------------------------------------------------------------------------
/WPF/Demo/Views/Extending.xaml:
--------------------------------------------------------------------------------
 1 | <UserControl x:Class="Demo.Extending" 
 2 |      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
 3 |      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4 |      xmlns:VerticalToggleSwitch="clr-namespace:Demo.Controls">
 5 |     <Grid VerticalAlignment="Top">
 6 |         <Grid.ColumnDefinitions>
 7 |             <ColumnDefinition Width="370"/>
 8 |             <ColumnDefinition Width="Auto"/>
 9 |             <ColumnDefinition Width="Auto"/>
10 |         </Grid.ColumnDefinitions>
11 |         <TextBlock TextWrapping="Wrap" HorizontalAlignment="Left" Text="The ToggleSwitch library exposes the base functionality of a toggle switch in the ToggleSwitchBase class. Extending this class allows for even further customized ToggleSwitch controls." />
12 |         <Line Stroke="#70595C64" Grid.Column="1" Y2="120" StrokeThickness="1" Margin="30,0" StrokeDashArray="1"/>
13 |         <VerticalToggleSwitch:VerticalToggleSwitch
14 |             UncheckedContent="LOW"
15 |             CheckedContent="HIGH"
16 |             HorizontalAlignment="Left"
17 |             Grid.Column="2" VerticalAlignment="Top"/>
18 |     </Grid>
19 | </UserControl>


--------------------------------------------------------------------------------
/WPF/Demo/Views/Extending.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows.Controls;
 2 | 
 3 | namespace Demo
 4 | {
 5 |     public partial class Extending : UserControl
 6 |     {
 7 |         public Extending()
 8 |         {
 9 |             InitializeComponent();
10 |         }
11 |     }
12 | }


--------------------------------------------------------------------------------
/WPF/Demo/Views/Styling.xaml:
--------------------------------------------------------------------------------
  1 | <UserControl 
  2 |      xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
  3 |      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  4 |      xmlns:ToggleSwitch="clr-namespace:ToggleSwitch;assembly=ToggleSwitch" 
  5 |     x:Class="Demo.Styling">
  6 | 
  7 |     <StackPanel>
  8 |         <TextBlock Text="A variety of styles can be achieved by simply choosing different color brushes, or by modifying the control template into a unique style." TextWrapping="Wrap" Margin="0,0,0,15"/>
  9 |         <Grid >
 10 |             <Grid.ColumnDefinitions>
 11 |                 <ColumnDefinition Width="*"/>
 12 |                 <ColumnDefinition Width="*"/>
 13 |                 <ColumnDefinition Width="Auto"/>
 14 |             </Grid.ColumnDefinitions>
 15 |             <Grid.RowDefinitions>
 16 |                 <RowDefinition Height="Auto"/>
 17 |                 <RowDefinition Height="Auto"/>
 18 |                 <RowDefinition Height="Auto"/>
 19 |             </Grid.RowDefinitions>
 20 |             <StackPanel HorizontalAlignment="Left" Grid.Row="1">
 21 |                 <TextBlock Text="iPhone" HorizontalAlignment="Left" />
 22 |                 <ToggleSwitch:HorizontalToggleSwitch
 23 |                     Style="{StaticResource iPhoneToggleSwitchStyle}" 
 24 |                     IsChecked="True" 
 25 |                     Margin="0,5,0,10" 
 26 |                     HorizontalAlignment="Left" />
 27 |             </StackPanel>
 28 |             <StackPanel Grid.Column="1" HorizontalAlignment="Left" Grid.Row="1">
 29 |                 <TextBlock Text="Carbon" HorizontalAlignment="Left" />
 30 |                 <ToggleSwitch:HorizontalToggleSwitch 
 31 |                     ThumbTemplate="{StaticResource SimpleThumbTemplate}"
 32 |                     FontSize="12"
 33 |                     BorderBrush="#FF6A6A6A"
 34 |                     UncheckedForeground="White" 
 35 |                     UncheckedContent="Off" 
 36 |                     CheckedContent="On" 
 37 |                     IsChecked="True" Margin="0,5,0,10" HorizontalAlignment="Left">
 38 |                     <ToggleSwitch:HorizontalToggleSwitch.ThumbBrush>
 39 |                         <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
 40 |                             <GradientStop Color="#FFB3B5B7" Offset="1"/>
 41 |                             <GradientStop Color="#FFEDEEEE"/>
 42 |                         </LinearGradientBrush>
 43 |                     </ToggleSwitch:HorizontalToggleSwitch.ThumbBrush>
 44 |                     <ToggleSwitch:HorizontalToggleSwitch.UncheckedBackground>
 45 |                         <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
 46 |                             <GradientStop Color="#FFE1E2E2"/>
 47 |                             <GradientStop Color="#FF555555"/>
 48 |                         </LinearGradientBrush>
 49 |                     </ToggleSwitch:HorizontalToggleSwitch.UncheckedBackground>
 50 |                     <ToggleSwitch:HorizontalToggleSwitch.CheckedBackground>
 51 |                         <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
 52 |                             <GradientStop Color="#FF6E97B7" Offset="1"/>
 53 |                             <GradientStop Color="#FF46738A"/>
 54 |                         </LinearGradientBrush>
 55 |                     </ToggleSwitch:HorizontalToggleSwitch.CheckedBackground>
 56 |                 </ToggleSwitch:HorizontalToggleSwitch>
 57 |             </StackPanel>
 58 |             <StackPanel Grid.Column="2" HorizontalAlignment="Left" Grid.Row="1">
 59 |                 <TextBlock Text="OS X" HorizontalAlignment="Left" />
 60 |                 <ToggleSwitch:HorizontalToggleSwitch 
 61 |                     CheckedContent="ON" 
 62 |                     UncheckedContent="OFF"
 63 |                     Style="{StaticResource SafariSwitchStyle}" Margin="0,5,0,10" HorizontalAlignment="Left" />
 64 |             </StackPanel>
 65 |             <StackPanel Grid.Row="2" HorizontalAlignment="Left">
 66 |                 <TextBlock Text="iOS 5" HorizontalAlignment="Left" Margin="0,15,0,5" />
 67 |                 <ToggleSwitch:HorizontalToggleSwitch
 68 |                     Style="{StaticResource iOS5ToggleSwitchStyle}" 
 69 |                     IsChecked="True" HorizontalAlignment="Left" />
 70 |             </StackPanel>
 71 |             <StackPanel Grid.Column="1" Grid.Row="2" HorizontalAlignment="Left">
 72 |                 <TextBlock Text="Metro" HorizontalAlignment="Left" Margin="0,15,0,5" />
 73 |                 <ToggleSwitch:HorizontalToggleSwitch
 74 |                     BorderBrush="#FF1F1F1F"
 75 |                     Width="78" 
 76 |                     UncheckedBackground="#FF333430" 
 77 |                     UncheckedForeground="#FF999999" 
 78 |                     ThumbSize="38" 
 79 |                     Style="{StaticResource MetroToggleSwitchStyle}" IsChecked="True" HorizontalAlignment="Left">
 80 |                     <ToggleSwitch:HorizontalToggleSwitch.CheckedBackground>
 81 |                         <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
 82 |                             <GradientStop Color="#FF3EB3EC"/>
 83 |                             <GradientStop Color="#FF349BE6" Offset="1"/>
 84 |                         </LinearGradientBrush>
 85 |                     </ToggleSwitch:HorizontalToggleSwitch.CheckedBackground>
 86 |                     <ToggleSwitch:HorizontalToggleSwitch.ThumbBrush>
 87 |                         <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
 88 |                             <GradientStop Color="#FF4D4E48"/>
 89 |                             <GradientStop Color="#FF333430" Offset="1"/>
 90 |                             <GradientStop Color="#FF333330" Offset="0.021"/>
 91 |                         </LinearGradientBrush>
 92 |                     </ToggleSwitch:HorizontalToggleSwitch.ThumbBrush>
 93 |                 </ToggleSwitch:HorizontalToggleSwitch>
 94 |             </StackPanel>
 95 |             <StackPanel Grid.Column="2" Grid.Row="2" HorizontalAlignment="Left">
 96 |                 <TextBlock Text="Brushed metal" HorizontalAlignment="Left" Margin="0,15,0,5" />
 97 |                 <ToggleSwitch:HorizontalToggleSwitch 
 98 |                     Style="{StaticResource LightBulbToggleSwitchStyle}" HorizontalAlignment="Left">
 99 |                     <ToggleSwitch:HorizontalToggleSwitch.UncheckedContent>
100 |                         <Image Source="../Images/lightOff.png" Height="32" Margin="0,-8,0,0" />
101 |                     </ToggleSwitch:HorizontalToggleSwitch.UncheckedContent>
102 |                     <ToggleSwitch:HorizontalToggleSwitch.CheckedContent>
103 |                         <Image Source="../Images/lightOn.png" Height="32" Margin="4,-8,0,0" />
104 |                     </ToggleSwitch:HorizontalToggleSwitch.CheckedContent>
105 |                 </ToggleSwitch:HorizontalToggleSwitch>
106 |             </StackPanel>
107 |         </Grid>
108 |     </StackPanel>
109 | </UserControl>


--------------------------------------------------------------------------------
/WPF/Demo/Views/Styling.xaml.cs:
--------------------------------------------------------------------------------
 1 | using System.Windows.Controls;
 2 | 
 3 | namespace Demo
 4 | {
 5 |     public partial class Styling : UserControl
 6 |     {
 7 |         public Styling()
 8 |         {
 9 |             InitializeComponent();
10 |         }
11 |     }
12 | }


--------------------------------------------------------------------------------
/WPF/Demo/app.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0"?>
2 | <configuration>
3 | </configuration>
4 | 


--------------------------------------------------------------------------------
/WPF/ToggleSwitch.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 11.00
 3 | # Visual Studio 2010
 4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Demo", "Demo\Demo.csproj", "{41423C97-80FA-4D0E-81A6-6E173A97A5B0}"
 5 | EndProject
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ToggleSwitch", "ToggleSwitch\ToggleSwitch.csproj", "{F9426059-27DB-45F0-9012-B1234965FBE0}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{41423C97-80FA-4D0E-81A6-6E173A97A5B0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{41423C97-80FA-4D0E-81A6-6E173A97A5B0}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{41423C97-80FA-4D0E-81A6-6E173A97A5B0}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{41423C97-80FA-4D0E-81A6-6E173A97A5B0}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 		{F9426059-27DB-45F0-9012-B1234965FBE0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
19 | 		{F9426059-27DB-45F0-9012-B1234965FBE0}.Debug|Any CPU.Build.0 = Debug|Any CPU
20 | 		{F9426059-27DB-45F0-9012-B1234965FBE0}.Release|Any CPU.ActiveCfg = Release|Any CPU
21 | 		{F9426059-27DB-45F0-9012-B1234965FBE0}.Release|Any CPU.Build.0 = Release|Any CPU
22 | 	EndGlobalSection
23 | 	GlobalSection(SolutionProperties) = preSolution
24 | 		HideSolutionNode = FALSE
25 | 	EndGlobalSection
26 | EndGlobal
27 | 


--------------------------------------------------------------------------------
/WPF/ToggleSwitch/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Reflection;
 3 | using System.Resources;
 4 | using System.Runtime.InteropServices;
 5 | using System.Windows;
 6 | 
 7 | // General Information about an assembly is controlled through the following 
 8 | // set of attributes. Change these attribute values to modify the information
 9 | // associated with an assembly.
10 | [assembly: AssemblyTrademark("")]
11 | [assembly: AssemblyCulture("")]
12 | [assembly: ThemeInfo(ResourceDictionaryLocation.SourceAssembly, ResourceDictionaryLocation.SourceAssembly)]
13 | 
14 | // Setting ComVisible to false makes the types in this assembly not visible 
15 | // to COM components.  If you need to access a type in this assembly from 
16 | // COM, set the ComVisible attribute to true on that type.
17 | [assembly: ComVisible(false)]
18 | 
19 | // The following GUID is for the ID of the typelib if this project is exposed to COM
20 | [assembly: Guid("528c2286-1b0e-4419-972a-b28dd5a33232")]
21 | 
22 | [assembly: NeutralResourcesLanguageAttribute("en")]
23 | [assembly: CLSCompliant(true)]


--------------------------------------------------------------------------------
/WPF/ToggleSwitch/Themes/Generic.xaml:
--------------------------------------------------------------------------------
  1 | <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  2 |                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  3 |                     xmlns:Borders="clr-namespace:ToggleSwitch.Borders"
  4 |                     xmlns:ToggleSwitch="clr-namespace:ToggleSwitch"
  5 |                     xmlns:Utils="clr-namespace:ToggleSwitch.Utils">
  6 | 
  7 |     <!--  ClippingBorder style  -->
  8 |     <Style TargetType="Borders:ClippingBorder">
  9 |         <Setter Property="ClipContent" Value="True" />
 10 |         <Setter Property="IsTabStop" Value="False" />
 11 |         <Setter Property="Focusable" Value="False" />
 12 |         <Setter Property="Template">
 13 |             <Setter.Value>
 14 |                 <ControlTemplate TargetType="Borders:ClippingBorder">
 15 |                     <Border x:Name="PART_Border"
 16 |                             Background="{TemplateBinding Background}"
 17 |                             BorderBrush="{TemplateBinding BorderBrush}"
 18 |                             BorderThickness="{TemplateBinding BorderThickness}"
 19 |                             CornerRadius="{TemplateBinding CornerRadius}">
 20 |                         <Grid>
 21 |                             <ContentControl x:Name="PART_TopLeftContentControl"
 22 |                                             HorizontalAlignment="Stretch"
 23 |                                             VerticalAlignment="Stretch"
 24 |                                             HorizontalContentAlignment="Stretch"
 25 |                                             VerticalContentAlignment="Stretch" IsTabStop="False" Focusable="False">
 26 |                                 <ContentControl.Clip>
 27 |                                     <RectangleGeometry x:Name="PART_TopLeftClip" />
 28 |                                 </ContentControl.Clip>
 29 |                                 <ContentControl x:Name="PART_TopRightContentControl"
 30 |                                                 HorizontalAlignment="Stretch"
 31 |                                                 VerticalAlignment="Stretch"
 32 |                                                 HorizontalContentAlignment="Stretch"
 33 |                                                 VerticalContentAlignment="Stretch" IsTabStop="False" Focusable="False">
 34 |                                     <ContentControl.Clip>
 35 |                                         <RectangleGeometry x:Name="PART_TopRightClip" />
 36 |                                     </ContentControl.Clip>
 37 |                                     <ContentControl x:Name="PART_BottomRightContentControl"
 38 |                                                     HorizontalAlignment="Stretch"
 39 |                                                     VerticalAlignment="Stretch"
 40 |                                                     HorizontalContentAlignment="Stretch"
 41 |                                                     VerticalContentAlignment="Stretch" IsTabStop="False" Focusable="False">
 42 |                                         <ContentControl.Clip>
 43 |                                             <RectangleGeometry x:Name="PART_BottomRightClip" />
 44 |                                         </ContentControl.Clip>
 45 |                                         <ContentControl x:Name="PART_BottomLeftContentControl"
 46 |                                                         HorizontalAlignment="Stretch"
 47 |                                                         VerticalAlignment="Stretch"
 48 |                                                         HorizontalContentAlignment="Stretch"
 49 |                                                         VerticalContentAlignment="Stretch" IsTabStop="False" Focusable="False">
 50 |                                             <ContentControl.Clip>
 51 |                                                 <RectangleGeometry x:Name="PART_BottomLeftClip" />
 52 |                                             </ContentControl.Clip>
 53 |                                             <ContentPresenter Margin="{TemplateBinding Padding}" />
 54 |                                         </ContentControl>
 55 |                                     </ContentControl>
 56 |                                 </ContentControl>
 57 |                             </ContentControl>
 58 |                         </Grid>
 59 |                     </Border>
 60 |                 </ControlTemplate>
 61 |             </Setter.Value>
 62 |         </Setter>
 63 |     </Style>
 64 | 
 65 |     <!--  InnerGlowBorder style  -->
 66 |     <Style TargetType="Borders:InnerGlowBorder">
 67 |         <Setter Property="InnerGlowSize" Value="10,10,10,10" />
 68 |         <Setter Property="InnerGlowOpacity" Value="0.5" />
 69 |         <Setter Property="InnerGlowColor" Value="#ff000000" />
 70 |         <Setter Property="ClipContent" Value="True" />
 71 |         <Setter Property="ContentZIndex" Value="0" />
 72 |         <Setter Property="Background" Value="#ffffffff" />
 73 |         <Setter Property="BorderBrush" Value="#ff000000" />
 74 |         <Setter Property="BorderThickness" Value="1,1,1,1" />
 75 |         <Setter Property="IsTabStop" Value="False" />
 76 |         <Setter Property="Focusable" Value="False" />
 77 |         <Setter Property="Template">
 78 |             <Setter.Value>
 79 |                 <ControlTemplate TargetType="Borders:InnerGlowBorder">
 80 |                     <Borders:ClippingBorder Background="{TemplateBinding Background}"
 81 |                                             BorderBrush="{TemplateBinding BorderBrush}"
 82 |                                             BorderThickness="{TemplateBinding BorderThickness}"
 83 |                                             ClipContent="{TemplateBinding ClipContent}"
 84 |                                             CornerRadius="{TemplateBinding CornerRadius}">
 85 |                         <Grid>
 86 |                             <ContentPresenter Margin="{TemplateBinding Padding}" Canvas.ZIndex="{TemplateBinding ContentZIndex}" />
 87 |                             <Border x:Name="PART_LeftGlow"
 88 |                                     Width="10"
 89 |                                     HorizontalAlignment="Left"
 90 |                                     VerticalAlignment="Stretch"
 91 |                                     Canvas.ZIndex="0"
 92 |                                     IsHitTestVisible="False"
 93 |                                     Opacity="{TemplateBinding InnerGlowOpacity}">
 94 |                                 <Border.Background>
 95 |                                     <LinearGradientBrush StartPoint="0, 0.5" EndPoint="1, 0.5">
 96 |                                         <GradientStop x:Name="PART_LeftGlowStop0" Offset="0" Color="#ff000000" />
 97 |                                         <GradientStop x:Name="PART_LeftGlowStop1" Offset="1" Color="#00000000" />
 98 |                                     </LinearGradientBrush>
 99 |                                 </Border.Background>
100 |                             </Border>
101 |                             <Border x:Name="PART_TopGlow"
102 |                                     Height="10"
103 |                                     HorizontalAlignment="Stretch"
104 |                                     VerticalAlignment="Top"
105 |                                     Canvas.ZIndex="0"
106 |                                     IsHitTestVisible="False"
107 |                                     Opacity="{TemplateBinding InnerGlowOpacity}">
108 |                                 <Border.Background>
109 |                                     <LinearGradientBrush StartPoint="0.5, 0" EndPoint="0.5, 1">
110 |                                         <GradientStop x:Name="PART_TopGlowStop0" Offset="0" Color="#ff000000" />
111 |                                         <GradientStop x:Name="PART_TopGlowStop1" Offset="1" Color="#00000000" />
112 |                                     </LinearGradientBrush>
113 |                                 </Border.Background>
114 |                             </Border>
115 |                             <Border x:Name="PART_RightGlow"
116 |                                     Width="10"
117 |                                     HorizontalAlignment="Right"
118 |                                     VerticalAlignment="Stretch"
119 |                                     Canvas.ZIndex="0"
120 |                                     IsHitTestVisible="False"
121 |                                     Opacity="{TemplateBinding InnerGlowOpacity}">
122 |                                 <Border.Background>
123 |                                     <LinearGradientBrush StartPoint="1, 0.5" EndPoint="0, 0.5">
124 |                                         <GradientStop x:Name="PART_RightGlowStop0" Offset="0" Color="#ff000000" />
125 |                                         <GradientStop x:Name="PART_RightGlowStop1" Offset="1" Color="#00000000" />
126 |                                     </LinearGradientBrush>
127 |                                 </Border.Background>
128 |                             </Border>
129 |                             <Border x:Name="PART_BottomGlow"
130 |                                     Height="10"
131 |                                     HorizontalAlignment="Stretch"
132 |                                     VerticalAlignment="Bottom"
133 |                                     Canvas.ZIndex="0"
134 |                                     IsHitTestVisible="False"
135 |                                     Opacity="{TemplateBinding InnerGlowOpacity}">
136 |                                 <Border.Background>
137 |                                     <LinearGradientBrush StartPoint="0.5, 1" EndPoint="0.5, 0">
138 |                                         <GradientStop x:Name="PART_BottomGlowStop0" Offset="0" Color="#ff000000" />
139 |                                         <GradientStop x:Name="PART_BottomGlowStop1" Offset="1" Color="#00000000" />
140 |                                     </LinearGradientBrush>
141 |                                 </Border.Background>
142 |                             </Border>
143 |                         </Grid>
144 |                     </Borders:ClippingBorder>
145 |                 </ControlTemplate>
146 |             </Setter.Value>
147 |         </Setter>
148 |     </Style>
149 | 
150 |     <!--  OuterGlowBorder style  -->
151 |     <Style TargetType="Borders:OuterGlowBorder">
152 |         <Setter Property="OuterGlowSize" Value="10" />
153 |         <Setter Property="OuterGlowOpacity" Value="0.5" />
154 |         <Setter Property="OuterGlowColor" Value="#ff000000" />
155 |         <Setter Property="ClipContent" Value="True" />
156 |         <Setter Property="Background" Value="#ffffffff" />
157 |         <Setter Property="BorderBrush" Value="#ff000000" />
158 |         <Setter Property="BorderThickness" Value="1" />
159 |         <Setter Property="IsTabStop" Value="False" />
160 |         <Setter Property="Focusable" Value="False" />
161 |         <Setter Property="Template">
162 |             <Setter.Value>
163 |                 <ControlTemplate TargetType="Borders:OuterGlowBorder">
164 |                     <Grid>
165 |                         <Border x:Name="PART_OuterGlowBorder"
166 |                                 HorizontalAlignment="Stretch"
167 |                                 VerticalAlignment="Stretch"
168 |                                 CornerRadius="{TemplateBinding ShadowCornerRadius}"
169 |                                 IsHitTestVisible="False"
170 |                                 Opacity="{TemplateBinding OuterGlowOpacity}">
171 |                             <Border.Background>
172 |                                 <LinearGradientBrush MappingMode="RelativeToBoundingBox" StartPoint="0.5,0" EndPoint="0.5,1">
173 |                                     <GradientStop x:Name="PART_ShadowOuterStop1" Offset="0" Color="#00000000" />
174 |                                     <GradientStop x:Name="PART_ShadowVertical1" Offset="0.1" Color="#ff000000" />
175 |                                     <GradientStop x:Name="PART_ShadowVertical2" Offset="0.9" Color="#ff000000" />
176 |                                     <GradientStop x:Name="PART_ShadowOuterStop2" Offset="1" Color="#00000000" />
177 |                                 </LinearGradientBrush>
178 |                             </Border.Background>
179 |                             <Border.OpacityMask>
180 |                                 <LinearGradientBrush MappingMode="RelativeToBoundingBox" StartPoint="0.0,0.5" EndPoint="1.0,0.5">
181 |                                     <GradientStop Offset="0" Color="#00000000" />
182 |                                     <GradientStop x:Name="PART_ShadowHorizontal1" Offset="0.1" Color="#FF000000" />
183 |                                     <GradientStop x:Name="PART_ShadowHorizontal2" Offset="0.9" Color="#FF000000" />
184 |                                     <GradientStop Offset="1" Color="#00000000" />
185 |                                 </LinearGradientBrush>
186 |                             </Border.OpacityMask>
187 |                         </Border>
188 |                         <Borders:ClippingBorder Background="{TemplateBinding Background}"
189 |                                                 BorderBrush="{TemplateBinding BorderBrush}"
190 |                                                 BorderThickness="{TemplateBinding BorderThickness}"
191 |                                                 ClipContent="{TemplateBinding ClipContent}"
192 |                                                 CornerRadius="{TemplateBinding CornerRadius}"
193 |                                                 Padding="{TemplateBinding Padding}">
194 |                             <ContentPresenter />
195 |                         </Borders:ClippingBorder>
196 |                     </Grid>
197 |                 </ControlTemplate>
198 |             </Setter.Value>
199 |         </Setter>
200 |     </Style>
201 | 
202 |     <ControlTemplate x:Key="PresenterContentTemplate" TargetType="ContentControl">
203 |         <Viewbox Margin="{TemplateBinding Padding}"
204 |                  HorizontalAlignment="Stretch"
205 |                  VerticalAlignment="Stretch"
206 |                  StretchDirection="DownOnly">
207 |             <ContentPresenter HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
208 |                               VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
209 |                               Content="{TemplateBinding Content}" />
210 |         </Viewbox>
211 |     </ControlTemplate>
212 |     <ControlTemplate x:Key="HorizontalThumbTemplate" TargetType="Thumb">
213 |         <Grid Background="Transparent">
214 |             <VisualStateManager.VisualStateGroups>
215 |                 <VisualStateGroup x:Name="CommonStates">
216 |                     <VisualState x:Name="Normal" />
217 |                     <VisualState x:Name="MouseOver">
218 |                         <Storyboard>
219 |                             <DoubleAnimation Duration="0"
220 |                                              Storyboard.TargetName="BackgroundAnimation"
221 |                                              Storyboard.TargetProperty="Opacity"
222 |                                              To="0.05" />
223 |                         </Storyboard>
224 |                     </VisualState>
225 |                     <VisualState x:Name="Pressed">
226 |                         <Storyboard>
227 |                             <DoubleAnimation Duration="0"
228 |                                              Storyboard.TargetName="BackgroundAnimation"
229 |                                              Storyboard.TargetProperty="Opacity"
230 |                                              To="0.25" />
231 |                         </Storyboard>
232 |                     </VisualState>
233 |                     <VisualState x:Name="Disabled">
234 |                         <Storyboard>
235 |                             <DoubleAnimation Duration="0"
236 |                                              Storyboard.TargetName="DisabledVisualElement"
237 |                                              Storyboard.TargetProperty="Opacity"
238 |                                              To=".55" />
239 |                         </Storyboard>
240 |                     </VisualState>
241 |                 </VisualStateGroup>
242 |                 <VisualStateGroup x:Name="FocusStates">
243 |                     <VisualState x:Name="Focused">
244 |                         <Storyboard>
245 |                             <DoubleAnimation Duration="0"
246 |                                              Storyboard.TargetName="FocusVisualElement"
247 |                                              Storyboard.TargetProperty="Opacity"
248 |                                              To="0.05" />
249 |                         </Storyboard>
250 |                     </VisualState>
251 |                     <VisualState x:Name="Unfocused" />
252 |                 </VisualStateGroup>
253 |                 <VisualStateGroup x:Name="CheckStates">
254 |                     <VisualState x:Name="Unchecked" />
255 |                     <VisualState x:Name="Checked">
256 |                         <Storyboard>
257 |                             <DoubleAnimation Duration="0" To="-1" Storyboard.TargetProperty="(UIElement.RenderTransform).(ScaleTransform.ScaleX)" Storyboard.TargetName="path"/>
258 |                         </Storyboard>
259 |                     </VisualState>
260 |                 </VisualStateGroup>
261 |             </VisualStateManager.VisualStateGroups>
262 |             <Borders:OuterGlowBorder Background="Transparent"
263 |                                      BorderThickness="0"
264 |                                      CornerRadius="4"
265 |                                      OuterGlowColor="Black"
266 |                                      OuterGlowOpacity="0.15"
267 |                                      OuterGlowSize="4"
268 |                                      ShadowCornerRadius="8">
269 |                 <Grid>
270 |                     <Borders:ClippingBorder x:Name="Background"
271 |                                             Background="White"
272 |                                             BorderBrush="{TemplateBinding BorderBrush}"
273 |                                             BorderThickness="{TemplateBinding BorderThickness}"
274 |                                             CornerRadius="4">
275 |                         <Border BorderBrush="#FFEBEBEB" BorderThickness="1" CornerRadius="3" Background="{TemplateBinding Background}">
276 |                             <Path x:Name="path" Data="M3.6,2.6 L10,2.6 L10,6.6 L3.6,6.6 z M10,0 L15.5,4.6 L10,9.4 z" Fill="#AA767676" Stretch="Fill" StrokeThickness="0" RenderTransformOrigin="0.5,0.5" Margin="7,5" >
277 |                                 <Path.RenderTransform>
278 |                                     <ScaleTransform/>
279 |                                 </Path.RenderTransform>
280 |                             </Path>
281 |                         </Border>
282 |                     </Borders:ClippingBorder>
283 |                     <Borders:ClippingBorder x:Name="BackgroundAnimation"
284 |                                             Background="Black"
285 |                                             BorderBrush="Black"
286 |                                             BorderThickness="{TemplateBinding BorderThickness}"
287 |                                             CornerRadius="4"
288 |                                             Opacity="0" />
289 |                     <Rectangle x:Name="FocusVisualElement"
290 |                                Margin="1"
291 |                                IsHitTestVisible="True"
292 |                                Opacity="0"
293 |                                RadiusX="4"
294 |                                RadiusY="4"
295 |                                StrokeThickness="1" />
296 |                     <Rectangle x:Name="DisabledVisualElement"
297 |                     	Fill="#FFFFFFFF"
298 |                     	Opacity="0"
299 |                     	RadiusX="4"
300 |                     	RadiusY="4" IsHitTestVisible="False" />
301 |                 </Grid>
302 |             </Borders:OuterGlowBorder>
303 |         </Grid>
304 |     </ControlTemplate>
305 |     
306 |     <ControlTemplate x:Key="HorizontalToggleSwitchTemplate" TargetType="ToggleSwitch:HorizontalToggleSwitch">
307 |         <Grid>
308 |             <VisualStateManager.VisualStateGroups>
309 |                 <VisualStateGroup x:Name="CommonStates">
310 |                     <VisualState x:Name="Normal" />
311 |                     <VisualState x:Name="Disabled">
312 |                         <Storyboard>
313 |                             <ObjectAnimationUsingKeyFrames Storyboard.TargetName="DisabledOverlay" Storyboard.TargetProperty="(UIElement.Visibility)">
314 |                                 <DiscreteObjectKeyFrame KeyTime="0">
315 |                                     <DiscreteObjectKeyFrame.Value>
316 |                                         <Visibility>Visible</Visibility>
317 |                                     </DiscreteObjectKeyFrame.Value>
318 |                                 </DiscreteObjectKeyFrame>
319 |                             </ObjectAnimationUsingKeyFrames>
320 |                         </Storyboard>
321 |                     </VisualState>
322 |                     <VisualState x:Name="MouseOver" />
323 |                     <VisualState x:Name="Pressed" />
324 |                 </VisualStateGroup>
325 |                 <VisualStateGroup x:Name="CheckStates">
326 |                     <VisualStateGroup.Transitions>
327 |                         <VisualTransition GeneratedDuration="0:0:0.10" To="Unchecked" />
328 |                         <VisualTransition GeneratedDuration="0:0:0.10" To="Checked" />
329 |                     </VisualStateGroup.Transitions>
330 |                     <VisualState x:Name="Checked" />
331 |                     <VisualState x:Name="Unchecked" />
332 |                     <VisualState x:Name="DraggingChecked" />
333 |                     <VisualState x:Name="DraggingUnchecked" />
334 |                 </VisualStateGroup>
335 |                 <VisualStateGroup x:Name="FocusStates">
336 |                     <VisualState x:Name="Unfocused" />
337 |                     <VisualState x:Name="Focused" />
338 |                 </VisualStateGroup>
339 |             </VisualStateManager.VisualStateGroups>
340 |             <Borders:ClippingBorder x:Name="SwitchRoot"
341 |                                                 BorderBrush="{TemplateBinding BorderBrush}"
342 |                                                 BorderThickness="1"
343 |                                                 CornerRadius="4">
344 |                 <Canvas MinWidth="{TemplateBinding ThumbSize}" MinHeight="{TemplateBinding FontSize}">
345 |                     <Utils:ActualSizePropertyProxy x:Name="ActualSizeProxy"
346 |                                                                Element="{Binding Mode=OneWay,RelativeSource={RelativeSource TemplatedParent}}"
347 |                                                                Visibility="Collapsed" IsHitTestVisible="False" />
348 |                     <Grid x:Name="SwitchTrack"
349 |                                       Height="{Binding ActualHeightValue, ElementName=ActualSizeProxy, Mode=OneWay}"
350 |                                       Margin="0,-1,0,0"
351 |                                       Cursor="Hand">
352 |                         <StackPanel Orientation="Horizontal">
353 |                             <Border Margin="-1,0,0,0"
354 |                                                 Background="{TemplateBinding CheckedBackground}"
355 |                                                 Padding="1,0,0,0">
356 |                                 <ContentControl x:Name="SwitchChecked"
357 |                                                             Margin="{TemplateBinding Padding}"
358 |                                                             HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
359 |                                                             VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
360 |                                                             Content="{TemplateBinding CheckedContent}"
361 |                                                             FontFamily="{TemplateBinding FontFamily}"
362 |                                                             FontSize="{TemplateBinding FontSize}"
363 |                                                             Foreground="{TemplateBinding CheckedForeground}"
364 |                                                             HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
365 |                                                             IsTabStop="False"
366 |                                                             Padding="0,0,22,0"
367 |                                                             Template="{TemplateBinding ContentTemplate}"
368 |                                                             VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}" Focusable="False" />
369 |                             </Border>
370 |                             <Border Margin="-1,0,0,0" Background="{TemplateBinding UncheckedBackground}">
371 |                                 <ContentControl x:Name="SwitchUnchecked"
372 |                                                             Margin="{TemplateBinding Padding}"
373 |                                                             HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
374 |                                                             VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
375 |                                                             Content="{TemplateBinding UncheckedContent}"
376 |                                                             Focusable="False"
377 |                                                             FontFamily="{TemplateBinding FontFamily}"
378 |                                                             FontSize="{TemplateBinding FontSize}"
379 |                                                             Foreground="{TemplateBinding UncheckedForeground}"
380 |                                                             HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
381 |                                                             IsTabStop="False"
382 |                                                             Template="{TemplateBinding ContentTemplate}"
383 |                                                             VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}" />
384 |                             </Border>
385 |                         </StackPanel>
386 |                     </Grid>
387 |                     <Borders:InnerGlowBorder Width="{Binding ActualWidthValue, ElementName=ActualSizeProxy, Mode=OneWay}"
388 |                                                          Height="{Binding ActualHeightValue, ElementName=ActualSizeProxy, Mode=OneWay}"
389 |                                                          Margin="-1,-1,0,0"
390 |                                                          Background="#00000000"
391 |                                                          BorderThickness="0"
392 |                                                          CornerRadius="4"
393 |                                                          InnerGlowColor="Black"
394 |                                                          InnerGlowOpacity="0.25"
395 |                                                          InnerGlowSize="2,4,2,0" />
396 |                     <Thumb x:Name="SwitchThumb"
397 |                                        Width="{TemplateBinding ThumbSize}"
398 |                                        Height="{Binding ActualHeightValue, ElementName=ActualSizeProxy, Mode=OneWay}"
399 |                                        Margin="0,-1,0,0"
400 |                                        HorizontalAlignment="Left"
401 |                                        Background="{TemplateBinding ThumbBrush}"
402 |                                        BorderBrush="{TemplateBinding BorderBrush}"
403 |                                        Cursor="Hand"
404 |                                        Template="{TemplateBinding ThumbTemplate}" IsTabStop="False" />
405 |                 </Canvas>
406 |             </Borders:ClippingBorder>
407 |             <Border x:Name="DisabledOverlay"
408 |                                 Background="#AAEEEEEE"
409 |                                 CornerRadius="4"
410 |                                 Visibility="Collapsed" IsHitTestVisible="False" />
411 |         </Grid>
412 |     </ControlTemplate>
413 |     <Style TargetType="ToggleSwitch:HorizontalToggleSwitch">
414 |         <Setter Property="Width" Value="88" />
415 |         <Setter Property="Height" Value="25" />
416 |         <Setter Property="BorderBrush" Value="#77979797" />
417 |         <Setter Property="BorderThickness" Value="1" />
418 |         <Setter Property="Padding" Value="0,4" />
419 |         <Setter Property="UncheckedForeground" Value="White" />
420 |         <Setter Property="CheckedForeground" Value="White" />
421 |         <Setter Property="ThumbSize" Value="40" />
422 |         <Setter Property="FontWeight" Value="SemiBold" />
423 |         <Setter Property="FontFamily" Value="Arial" />
424 |         <Setter Property="FontSize" Value="13" />
425 |         <Setter Property="HorizontalAlignment" Value="Center" />
426 |         <Setter Property="VerticalAlignment" Value="Center" />
427 |         <Setter Property="HorizontalContentAlignment" Value="Center" />
428 |         <Setter Property="VerticalContentAlignment" Value="Center" />
429 |         <Setter Property="ContentTemplate" Value="{StaticResource PresenterContentTemplate}" />
430 |         <Setter Property="Template" Value="{StaticResource HorizontalToggleSwitchTemplate}"/>
431 |         <Setter Property="ToggleSwitch:ToggleSwitchBase.ThumbTemplate" Value="{StaticResource HorizontalThumbTemplate}" />
432 |         <Setter Property="CheckedBackground">
433 |             <Setter.Value>
434 |                 <LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
435 |                     <GradientStop Offset="1" Color="#FF5EAD09" />
436 |                     <GradientStop Color="#FF478108" />
437 |                 </LinearGradientBrush>
438 |             </Setter.Value>
439 |         </Setter>
440 |         <Setter Property="ToggleSwitch:HorizontalToggleSwitch.UncheckedBackground">
441 |             <Setter.Value>
442 |                 <LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
443 |                     <GradientStop Offset="1" Color="#FFC80000" />
444 |                     <GradientStop Color="#FFB00000" />
445 |                 </LinearGradientBrush>
446 |             </Setter.Value>
447 |         </Setter>
448 |         <Setter Property="ToggleSwitch:HorizontalToggleSwitch.ThumbBrush">
449 |             <Setter.Value>
450 |                 <LinearGradientBrush StartPoint="0.5,0" EndPoint="0.5,1">
451 |                     <GradientStop Offset="1" Color="#FFE2E2E2" />
452 |                     <GradientStop Color="#FFFDFCFD" />
453 |                     <GradientStop Offset="0.5" Color="#FFF8F8F8" />
454 |                     <GradientStop Offset="0.5" Color="#FFE8E8E8" />
455 |                 </LinearGradientBrush>
456 |             </Setter.Value>
457 |         </Setter>
458 |     </Style>
459 | </ResourceDictionary>


--------------------------------------------------------------------------------
/WPF/ToggleSwitch/ToggleSwitch.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 2 |   <PropertyGroup>
 3 |     <OutputType>Library</OutputType>
 4 |     <TargetFrameworks>net46;netcoreapp3.1</TargetFrameworks>
 5 |     <UseWPF>true</UseWPF>
 6 |   </PropertyGroup>
 7 |   <PropertyGroup>
 8 |     <AssemblyTitle>Toggle Switch Control Library</AssemblyTitle>
 9 |     <Product>Toggle Switch Control Library</Product>
10 |     <Copyright>Copyright © Eric Jensen 2020</Copyright>
11 |     <AssemblyVersion>1.2.0.0</AssemblyVersion>
12 |     <FileVersion>1.2.0.0</FileVersion>
13 |     <EnableNETAnalyzers>true</EnableNETAnalyzers>
14 |     <PackageProjectUrl>https://github.com/ejensen/toggle-switch-control</PackageProjectUrl>
15 |     <RepositoryUrl>https://github.com/ejensen/toggle-switch-control</RepositoryUrl>
16 |     <Company>Yeti Labs</Company>
17 |     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
18 |     <Authors>Eric Jensen</Authors>
19 |     <Version>1.2.0</Version>
20 |     <PackageIcon>icon.png</PackageIcon>
21 |     <PackageLicenseExpression>MIT</PackageLicenseExpression>
22 |     <RepositoryType>git</RepositoryType>
23 |   </PropertyGroup>
24 |   <ItemGroup>
25 |     <Compile Include="..\..\Common\Borders\ClippingBorder.cs">
26 |       <Link>Borders\ClippingBorder.cs</Link>
27 |     </Compile>
28 |     <Compile Include="..\..\Common\Borders\InnerGlowBorder.cs">
29 |       <Link>Borders\InnerGlowBorder.cs</Link>
30 |     </Compile>
31 |     <Compile Include="..\..\Common\Borders\OuterGlowBorder.cs">
32 |       <Link>Borders\OuterGlowBorder.cs</Link>
33 |     </Compile>
34 |     <Compile Include="..\..\Common\HorizontalToggleSwitch.cs">
35 |       <Link>HorizontalToggleSwitch.cs</Link>
36 |     </Compile>
37 |     <Compile Include="..\..\Common\ToggleSwitchBase.cs">
38 |       <Link>ToggleSwitchBase.cs</Link>
39 |     </Compile>
40 |     <Compile Include="..\..\Common\Utils\ActualSizePropertyProxy.cs">
41 |       <Link>Utils\ActualSizePropertyProxy.cs</Link>
42 |     </Compile>
43 |     <Compile Include="..\..\Common\Utils\HelperExtensions.cs">
44 |       <Link>Utils\HelperExtensions.cs</Link>
45 |     </Compile>
46 |   </ItemGroup>
47 |   <ItemGroup>
48 |     <EmbeddedResource Include="..\..\Common\Icons\ToggleSwitch.HorizontalToggleSwitch.Expression.Large.png" Link="Icons\ToggleSwitch.HorizontalToggleSwitch.Expression.Large.png" />
49 |     <EmbeddedResource Include="..\..\Common\Icons\ToggleSwitch.HorizontalToggleSwitch.Expression.Small.png" Link="Icons\ToggleSwitch.HorizontalToggleSwitch.Expression.Small.png" />
50 |     <EmbeddedResource Include="..\..\Common\Icons\ToggleSwitch.HorizontalToggleSwitch.VisualStudio.bmp" Link="Icons\ToggleSwitch.HorizontalToggleSwitch.VisualStudio.bmp" />
51 |   </ItemGroup>
52 |   <ItemGroup>
53 |     <None Include="..\..\icon.png">
54 |       <Pack>True</Pack>
55 |       <PackagePath></PackagePath>
56 |     </None>
57 |   </ItemGroup>
58 | </Project>


--------------------------------------------------------------------------------
/WPF/ToggleSwitch/ToggleSwitchKey.snk:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ejensen/toggle-switch-control/1761c450de096c7cea7ec1d81f337ed7f9e69624/WPF/ToggleSwitch/ToggleSwitchKey.snk


--------------------------------------------------------------------------------
/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ejensen/toggle-switch-control/1761c450de096c7cea7ec1d81f337ed7f9e69624/icon.png


--------------------------------------------------------------------------------