tsai
/
wpftoolkit
mirror of https://github.com/xceedsoftware/wpftoolkit.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

refactored new numeric editors and added the editors to the PropertyGrid control. Now time to start ripping out the old NumericUpDown control.

pull/1645/head
brianlagunas_cp 15 years ago
parent
51e6a10b9f
commit
8e5c79604a
8 changed files with 189 additions and 488 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 166
      ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/NumericUpDown/Implementation/DecimalUpDown.cs
  2. 166
      ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/NumericUpDown/Implementation/DoubleUpDown.cs
  3. 166
      ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/NumericUpDown/Implementation/IntegerUpDown.cs
  4. 154
      ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/NumericUpDown/Implementation/NumericUpDown.cs
  5. 4
      ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/DecimalUpDownEditor.cs
  6. 12
      ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/DoubleUpDownEditor.cs
  7. 6
      ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGrid.cs
  8. 3
      ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/WPFToolkit.Extended.csproj

166
ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/NumericUpDown/Implementation/DecimalUpDown.cs
View File

@ -1,138 +1,27 @@
using System;
using Microsoft.Windows.Controls.Primitives;
using System.Windows;
using System.Windows.Input;
namespace Microsoft.Windows.Controls
{
public class DecimalUpDown : UpDownBase<decimal?>
public class DecimalUpDown : NumericUpDown<decimal?>
{
#region Properties
#region DefaultValue
//can possibly be in base class
public static readonly DependencyProperty DefaultValueProperty = DependencyProperty.Register("DefaultValue", typeof(decimal), typeof(DecimalUpDown), new UIPropertyMetadata(default(decimal)));
public decimal DefaultValue
{
get { return (decimal)GetValue(DefaultValueProperty); }
set { SetValue(DefaultValueProperty, value); }
}
#endregion //DefaultValue
#region FormatString
public static readonly DependencyProperty FormatStringProperty = DependencyProperty.Register("FormatString", typeof(string), typeof(DecimalUpDown), new UIPropertyMetadata(String.Empty));
public string FormatString
{
get { return (string)GetValue(FormatStringProperty); }
set { SetValue(FormatStringProperty, value); }
}
#endregion //FormatString
#region Increment
public static readonly DependencyProperty IncrementProperty = DependencyProperty.Register("Increment", typeof(decimal), typeof(DecimalUpDown), new PropertyMetadata(1m));
public decimal Increment
{
get { return (decimal)GetValue(IncrementProperty); }
set { SetValue(IncrementProperty, value); }
}
#endregion
#region Maximum
public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register("Maximum", typeof(decimal), typeof(DecimalUpDown), new UIPropertyMetadata(decimal.MaxValue, OnMaximumChanged));
public decimal Maximum
{
get { return (decimal)GetValue(MaximumProperty); }
set { SetValue(MaximumProperty, value); }
}
private static void OnMaximumChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
DecimalUpDown decimalUpDown = o as DecimalUpDown;
if (decimalUpDown != null)
decimalUpDown.OnMaximumChanged((decimal)e.OldValue, (decimal)e.NewValue);
}
protected virtual void OnMaximumChanged(decimal oldValue, decimal newValue)
{
//SetValidSpinDirection();
}
#endregion //Maximum
#region Minimum
public static readonly DependencyProperty MinimumProperty = DependencyProperty.Register("Minimum", typeof(decimal), typeof(DecimalUpDown), new UIPropertyMetadata(decimal.MinValue, OnMinimumChanged));
public decimal Minimum
{
get { return (decimal)GetValue(MinimumProperty); }
set { SetValue(MinimumProperty, value); }
}
private static void OnMinimumChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
DecimalUpDown decimalUpDown = o as DecimalUpDown;
if (decimalUpDown != null)
decimalUpDown.OnMinimumChanged((decimal)e.OldValue, (decimal)e.NewValue);
}
protected virtual void OnMinimumChanged(decimal oldValue, decimal newValue)
{
//SetValidSpinDirection();
}
#endregion //Minimum
#region SelectAllOnGotFocus
public static readonly DependencyProperty SelectAllOnGotFocusProperty = DependencyProperty.Register("SelectAllOnGotFocus", typeof(bool), typeof(DecimalUpDown), new PropertyMetadata(false));
public bool SelectAllOnGotFocus
{
get { return (bool)GetValue(SelectAllOnGotFocusProperty); }
set { SetValue(SelectAllOnGotFocusProperty, value); }
}
#endregion //SelectAllOnGotFocus
#endregion //Properties
#region Constructors
static DecimalUpDown()
{
DefaultStyleKeyProperty.OverrideMetadata(typeof(DecimalUpDown), new FrameworkPropertyMetadata(typeof(DecimalUpDown)));
DefaultValueProperty.OverrideMetadata(typeof(DecimalUpDown), new FrameworkPropertyMetadata(default(decimal)));
IncrementProperty.OverrideMetadata(typeof(DecimalUpDown), new FrameworkPropertyMetadata(1m));
MaximumProperty.OverrideMetadata(typeof(DecimalUpDown), new FrameworkPropertyMetadata(decimal.MaxValue));
MinimumProperty.OverrideMetadata(typeof(DecimalUpDown), new FrameworkPropertyMetadata(decimal.MinValue));
}
#endregion //Constructors
#region Base Class Overrides
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
if (SelectAllOnGotFocus)
{
//in order to select all the text we must handle both the keybord (tabbing) and mouse (clicking) events
TextBox.GotKeyboardFocus += OnTextBoxGotKeyBoardFocus;
TextBox.PreviewMouseLeftButtonDown += OnTextBoxPreviewMouseLeftButtonDown;
}
//SetValidSpinDirection();
}
protected override decimal? OnCoerceValue(decimal? value)
{
if (value == null) return value;
decimal val = value.Value;
if (value < Minimum)
return Minimum;
else if (value > Maximum)
@ -185,51 +74,6 @@ namespace Microsoft.Windows.Controls
return Value.Value.ToString(FormatString, CultureInfo);
}
protected override void OnValueChanged(decimal? oldValue, decimal? newValue)
{
//SetValidSpinDirection();
base.OnValueChanged(oldValue, newValue);
}
#endregion //Base Class Overrides
#region Event Handlers
private void OnTextBoxGotKeyBoardFocus(object sender, RoutedEventArgs e)
{
TextBox.SelectAll();
}
void OnTextBoxPreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (!TextBox.IsKeyboardFocused)
{
e.Handled = true;
TextBox.Focus();
}
}
#endregion //Event Handlers
#region Methods
/// <summary>
/// Sets the valid spin direction based on current value, minimum and maximum.
/// </summary>
//private void SetValidSpinDirection()
//{
// ValidSpinDirections validDirections = ValidSpinDirections.None;
// if (Value < Maximum)
// validDirections = validDirections | ValidSpinDirections.Increase;
// if (Value > Minimum)
// validDirections = validDirections | ValidSpinDirections.Decrease;
// if (Spinner != null)
// Spinner.ValidSpinDirection = validDirections;
//}
#endregion //Methods
}
}

166
ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/NumericUpDown/Implementation/DoubleUpDown.cs
View File

@ -1,138 +1,27 @@
using System;
using Microsoft.Windows.Controls.Primitives;
using System.Windows;
using System.Windows.Input;
namespace Microsoft.Windows.Controls
{
public class DoubleUpDown : UpDownBase<double?>
public class DoubleUpDown : NumericUpDown<double?>
{
#region Properties
#region DefaultValue
//can possibly be in base class
public static readonly DependencyProperty DefaultValueProperty = DependencyProperty.Register("DefaultValue", typeof(double), typeof(DoubleUpDown), new UIPropertyMetadata(default(double)));
public double DefaultValue
{
get { return (double)GetValue(DefaultValueProperty); }
set { SetValue(DefaultValueProperty, value); }
}
#endregion //DefaultValue
#region FormatString
public static readonly DependencyProperty FormatStringProperty = DependencyProperty.Register("FormatString", typeof(string), typeof(DoubleUpDown), new UIPropertyMetadata(String.Empty));
public string FormatString
{
get { return (string)GetValue(FormatStringProperty); }
set { SetValue(FormatStringProperty, value); }
}
#endregion //FormatString
#region Increment
public static readonly DependencyProperty IncrementProperty = DependencyProperty.Register("Increment", typeof(double), typeof(DoubleUpDown), new PropertyMetadata(1d));
public double Increment
{
get { return (double)GetValue(IncrementProperty); }
set { SetValue(IncrementProperty, value); }
}
#endregion
#region Maximum
public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register("Maximum", typeof(double), typeof(DoubleUpDown), new UIPropertyMetadata(double.MaxValue, OnMaximumChanged));
public double Maximum
{
get { return (double)GetValue(MaximumProperty); }
set { SetValue(MaximumProperty, value); }
}
private static void OnMaximumChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
DoubleUpDown doubleUpDown = o as DoubleUpDown;
if (doubleUpDown != null)
doubleUpDown.OnMaximumChanged((double)e.OldValue, (double)e.NewValue);
}
protected virtual void OnMaximumChanged(double oldValue, double newValue)
{
//SetValidSpinDirection();
}
#endregion //Maximum
#region Minimum
public static readonly DependencyProperty MinimumProperty = DependencyProperty.Register("Minimum", typeof(double), typeof(DoubleUpDown), new UIPropertyMetadata(double.MinValue, OnMinimumChanged));
public double Minimum
{
get { return (double)GetValue(MinimumProperty); }
set { SetValue(MinimumProperty, value); }
}
private static void OnMinimumChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
DoubleUpDown doubleUpDown = o as DoubleUpDown;
if (doubleUpDown != null)
doubleUpDown.OnMinimumChanged((double)e.OldValue, (double)e.NewValue);
}
protected virtual void OnMinimumChanged(double oldValue, double newValue)
{
//SetValidSpinDirection();
}
#endregion //Minimum
#region SelectAllOnGotFocus
public static readonly DependencyProperty SelectAllOnGotFocusProperty = DependencyProperty.Register("SelectAllOnGotFocus", typeof(bool), typeof(DoubleUpDown), new PropertyMetadata(false));
public bool SelectAllOnGotFocus
{
get { return (bool)GetValue(SelectAllOnGotFocusProperty); }
set { SetValue(SelectAllOnGotFocusProperty, value); }
}
#endregion //SelectAllOnGotFocus
#endregion //Properties
#region Constructors
static DoubleUpDown()
{
DefaultStyleKeyProperty.OverrideMetadata(typeof(DoubleUpDown), new FrameworkPropertyMetadata(typeof(DoubleUpDown)));
DefaultValueProperty.OverrideMetadata(typeof(DoubleUpDown), new FrameworkPropertyMetadata(default(double)));
IncrementProperty.OverrideMetadata(typeof(DoubleUpDown), new FrameworkPropertyMetadata(1d));
MaximumProperty.OverrideMetadata(typeof(DoubleUpDown), new FrameworkPropertyMetadata(double.MaxValue));
MinimumProperty.OverrideMetadata(typeof(DoubleUpDown), new FrameworkPropertyMetadata(double.MinValue));
}
#endregion //Constructors
#region Base Class Overrides
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
if (SelectAllOnGotFocus)
{
//in order to select all the text we must handle both the keybord (tabbing) and mouse (clicking) events
TextBox.GotKeyboardFocus += OnTextBoxGotKeyBoardFocus;
TextBox.PreviewMouseLeftButtonDown += OnTextBoxPreviewMouseLeftButtonDown;
}
//SetValidSpinDirection();
}
protected override double? OnCoerceValue(double? value)
{
if (value == null) return value;
double val = value.Value;
if (value < Minimum)
return Minimum;
else if (value > Maximum)
@ -185,51 +74,6 @@ namespace Microsoft.Windows.Controls
return Value.Value.ToString(FormatString, CultureInfo);
}
protected override void OnValueChanged(double? oldValue, double? newValue)
{
//SetValidSpinDirection();
base.OnValueChanged(oldValue, newValue);
}
#endregion //Base Class Overrides
#region Event Handlers
private void OnTextBoxGotKeyBoardFocus(object sender, RoutedEventArgs e)
{
TextBox.SelectAll();
}
void OnTextBoxPreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (!TextBox.IsKeyboardFocused)
{
e.Handled = true;
TextBox.Focus();
}
}
#endregion //Event Handlers
#region Methods
/// <summary>
/// Sets the valid spin direction based on current value, minimum and maximum.
/// </summary>
//private void SetValidSpinDirection()
//{
// ValidSpinDirections validDirections = ValidSpinDirections.None;
// if (Value < Maximum)
// validDirections = validDirections | ValidSpinDirections.Increase;
// if (Value > Minimum)
// validDirections = validDirections | ValidSpinDirections.Decrease;
// if (Spinner != null)
// Spinner.ValidSpinDirection = validDirections;
//}
#endregion //Methods
}
}

166
ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/NumericUpDown/Implementation/IntegerUpDown.cs
View File

@ -1,138 +1,27 @@
using System;
using System.Windows;
using System.Windows.Input;
using Microsoft.Windows.Controls.Primitives;
namespace Microsoft.Windows.Controls
{
public class IntegerUpDown : UpDownBase<int?>
public class IntegerUpDown : NumericUpDown<int?>
{
#region Properties
#region DefaultValue
//can possibly be in base class
public static readonly DependencyProperty DefaultValueProperty = DependencyProperty.Register("DefaultValue", typeof(int), typeof(IntegerUpDown), new UIPropertyMetadata(default(int)));
public int DefaultValue
{
get { return (int)GetValue(DefaultValueProperty); }
set { SetValue(DefaultValueProperty, value); }
}
#endregion //DefaultValue
#region FormatString
public static readonly DependencyProperty FormatStringProperty = DependencyProperty.Register("FormatString", typeof(string), typeof(IntegerUpDown), new UIPropertyMetadata(String.Empty));
public string FormatString
{
get { return (string)GetValue(FormatStringProperty); }
set { SetValue(FormatStringProperty, value); }
}
#endregion //FormatString
#region Increment
public static readonly DependencyProperty IncrementProperty = DependencyProperty.Register("Increment", typeof(int), typeof(IntegerUpDown), new PropertyMetadata(1));
public int Increment
{
get { return (int)GetValue(IncrementProperty); }
set { SetValue(IncrementProperty, value); }
}
#endregion
#region Maximum
public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register("Maximum", typeof(int), typeof(IntegerUpDown), new UIPropertyMetadata(int.MaxValue, OnMaximumChanged));
public int Maximum
{
get { return (int)GetValue(MaximumProperty); }
set { SetValue(MaximumProperty, value); }
}
private static void OnMaximumChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
IntegerUpDown integerUpDown = o as IntegerUpDown;
if (integerUpDown != null)
integerUpDown.OnMaximumChanged((int)e.OldValue, (int)e.NewValue);
}
protected virtual void OnMaximumChanged(int oldValue, int newValue)
{
//SetValidSpinDirection();
}
#endregion //Maximum
#region Minimum
public static readonly DependencyProperty MinimumProperty = DependencyProperty.Register("Minimum", typeof(int), typeof(IntegerUpDown), new UIPropertyMetadata(int.MinValue, OnMinimumChanged));
public int Minimum
{
get { return (int)GetValue(MinimumProperty); }
set { SetValue(MinimumProperty, value); }
}
private static void OnMinimumChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
IntegerUpDown integerUpDown = o as IntegerUpDown;
if (integerUpDown != null)
integerUpDown.OnMinimumChanged((int)e.OldValue, (int)e.NewValue);
}
protected virtual void OnMinimumChanged(int oldValue, int newValue)
{
//SetValidSpinDirection();
}
#endregion //Minimum
#region SelectAllOnGotFocus
public static readonly DependencyProperty SelectAllOnGotFocusProperty = DependencyProperty.Register("SelectAllOnGotFocus", typeof(bool), typeof(IntegerUpDown), new PropertyMetadata(false));
public bool SelectAllOnGotFocus
{
get { return (bool)GetValue(SelectAllOnGotFocusProperty); }
set { SetValue(SelectAllOnGotFocusProperty, value); }
}
#endregion //SelectAllOnGotFocus
#endregion //Properties
#region Constructors
static IntegerUpDown()
{
DefaultStyleKeyProperty.OverrideMetadata(typeof(IntegerUpDown), new FrameworkPropertyMetadata(typeof(IntegerUpDown)));
DefaultValueProperty.OverrideMetadata(typeof(IntegerUpDown), new FrameworkPropertyMetadata(0));
IncrementProperty.OverrideMetadata(typeof(IntegerUpDown), new FrameworkPropertyMetadata(1));
MaximumProperty.OverrideMetadata(typeof(IntegerUpDown), new FrameworkPropertyMetadata(int.MaxValue));
MinimumProperty.OverrideMetadata(typeof(IntegerUpDown), new FrameworkPropertyMetadata(int.MinValue));
}
#endregion //Constructors
#region Base Class Overrides
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
if (SelectAllOnGotFocus)
{
//in order to select all the text we must handle both the keybord (tabbing) and mouse (clicking) events
TextBox.GotKeyboardFocus += OnTextBoxGotKeyBoardFocus;
TextBox.PreviewMouseLeftButtonDown += OnTextBoxPreviewMouseLeftButtonDown;
}
//SetValidSpinDirection();
}
protected override int? OnCoerceValue(int? value)
{
if (value == null) return value;
int val = value.Value;
if (value < Minimum)
return Minimum;
else if (value > Maximum)
@ -185,51 +74,6 @@ namespace Microsoft.Windows.Controls
return Value.Value.ToString(FormatString, CultureInfo);
}
protected override void OnValueChanged(int? oldValue, int? newValue)
{
//SetValidSpinDirection();
base.OnValueChanged(oldValue, newValue);
}
#endregion //Base Class Overrides
#region Event Handlers
private void OnTextBoxGotKeyBoardFocus(object sender, RoutedEventArgs e)
{
TextBox.SelectAll();
}
void OnTextBoxPreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (!TextBox.IsKeyboardFocused)
{
e.Handled = true;
TextBox.Focus();
}
}
#endregion //Event Handlers
#region Methods
/// <summary>
/// Sets the valid spin direction based on current value, minimum and maximum.
/// </summary>
//private void SetValidSpinDirection()
//{
// ValidSpinDirections validDirections = ValidSpinDirections.None;
// if (Value < Maximum)
// validDirections = validDirections | ValidSpinDirections.Increase;
// if (Value > Minimum)
// validDirections = validDirections | ValidSpinDirections.Decrease;
// if (Spinner != null)
// Spinner.ValidSpinDirection = validDirections;
//}
#endregion //Methods
}
}

154
ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/NumericUpDown/Implementation/NumericUpDown.cs
View File

@ -363,4 +363,158 @@ namespace Microsoft.Windows.Controls
#endregion //Methods
}
public abstract class NumericUpDown<T> : UpDownBase<T>
{
#region Properties
#region DefaultValue
public static readonly DependencyProperty DefaultValueProperty = DependencyProperty.Register("DefaultValue", typeof(T), typeof(NumericUpDown<T>), new UIPropertyMetadata(default(T)));
public T DefaultValue
{
get { return (T)GetValue(DefaultValueProperty); }
set { SetValue(DefaultValueProperty, value); }
}
#endregion //DefaultValue
#region FormatString
public static readonly DependencyProperty FormatStringProperty = DependencyProperty.Register("FormatString", typeof(string), typeof(NumericUpDown<T>), new UIPropertyMetadata(String.Empty));
public string FormatString
{
get { return (string)GetValue(FormatStringProperty); }
set { SetValue(FormatStringProperty, value); }
}
#endregion //FormatString
#region Increment
public static readonly DependencyProperty IncrementProperty = DependencyProperty.Register("Increment", typeof(T), typeof(NumericUpDown<T>), new PropertyMetadata(default(T)));
public T Increment
{
get { return (T)GetValue(IncrementProperty); }
set { SetValue(IncrementProperty, value); }
}
#endregion
#region Maximum
public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register("Maximum", typeof(T), typeof(NumericUpDown<T>), new UIPropertyMetadata(default(T), OnMaximumChanged));
public T Maximum
{
get { return (T)GetValue(MaximumProperty); }
set { SetValue(MaximumProperty, value); }
}
private static void OnMaximumChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
NumericUpDown<T> integerUpDown = o as NumericUpDown<T>;
if (integerUpDown != null)
integerUpDown.OnMaximumChanged((T)e.OldValue, (T)e.NewValue);
}
protected virtual void OnMaximumChanged(T oldValue, T newValue)
{
//SetValidSpinDirection();
}
#endregion //Maximum
#region Minimum
public static readonly DependencyProperty MinimumProperty = DependencyProperty.Register("Minimum", typeof(T), typeof(NumericUpDown<T>), new UIPropertyMetadata(default(T), OnMinimumChanged));
public T Minimum
{
get { return (T)GetValue(MinimumProperty); }
set { SetValue(MinimumProperty, value); }
}
private static void OnMinimumChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
NumericUpDown<T> integerUpDown = o as NumericUpDown<T>;
if (integerUpDown != null)
integerUpDown.OnMinimumChanged((T)e.OldValue, (T)e.NewValue);
}
protected virtual void OnMinimumChanged(T oldValue, T newValue)
{
//SetValidSpinDirection();
}
#endregion //Minimum
#region SelectAllOnGotFocus
public static readonly DependencyProperty SelectAllOnGotFocusProperty = DependencyProperty.Register("SelectAllOnGotFocus", typeof(bool), typeof(NumericUpDown<T>), new PropertyMetadata(false));
public bool SelectAllOnGotFocus
{
get { return (bool)GetValue(SelectAllOnGotFocusProperty); }
set { SetValue(SelectAllOnGotFocusProperty, value); }
}
#endregion //SelectAllOnGotFocus
#endregion //Properties
#region Base Class Overrides
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
if (SelectAllOnGotFocus)
{
//in order to select all the text we must handle both the keybord (tabbing) and mouse (clicking) events
TextBox.GotKeyboardFocus += OnTextBoxGotKeyBoardFocus;
TextBox.PreviewMouseLeftButtonDown += OnTextBoxPreviewMouseLeftButtonDown;
}
//SetValidSpinDirection();
}
#endregion //Base Class Overrides
#region Event Handlers
private void OnTextBoxGotKeyBoardFocus(object sender, RoutedEventArgs e)
{
TextBox.SelectAll();
}
void OnTextBoxPreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (!TextBox.IsKeyboardFocused)
{
e.Handled = true;
TextBox.Focus();
}
}
#endregion //Event Handlers
#region Methods
/// <summary>
/// Sets the valid spin direction based on current value, minimum and maximum.
/// </summary>
//private void SetValidSpinDirection()
//{
// ValidSpinDirections validDirections = ValidSpinDirections.None;
// if (Value < Maximum)
// validDirections = validDirections | ValidSpinDirections.Increase;
// if (Value > Minimum)
// validDirections = validDirections | ValidSpinDirections.Decrease;
// if (Spinner != null)
// Spinner.ValidSpinDirection = validDirections;
//}
#endregion //Methods
}
}

4
ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/NumericUpDownEditor.cs → ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/DecimalUpDownEditor.cs
View File

@ -2,11 +2,11 @@
namespace Microsoft.Windows.Controls.PropertyGrid.Editors
{
public class NumericUpDownEditor : TypeEditor<NumericUpDown>
public class DecimalUpDownEditor : TypeEditor<DecimalUpDown>
{
protected override void SetValueDependencyProperty()
{
ValueProperty = NumericUpDown.ValueProperty;
ValueProperty = DecimalUpDown.ValueProperty;
}
}
}

12
ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/Editors/DoubleUpDownEditor.cs
View File

@ -0,0 +1,12 @@
using System;
namespace Microsoft.Windows.Controls.PropertyGrid.Editors
{
public class DoubleUpDownEditor : TypeEditor<DoubleUpDown>
{
protected override void SetValueDependencyProperty()
{
ValueProperty = DoubleUpDown.ValueProperty;
}
}
}

6
ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/PropertyGrid/Implementation/PropertyGrid.cs
View File

@ -322,8 +322,10 @@ namespace Microsoft.Windows.Controls.PropertyGrid
editor = new TextBlockEditor();
else if (propertyItem.PropertyType == typeof(bool))
editor = new CheckBoxEditor();
//else if (propertyItem.PropertyType == typeof(double))
// editor = new NumericUpDownEditor();
else if (propertyItem.PropertyType == typeof(decimal) || propertyItem.PropertyType == typeof(decimal?))
editor = new DecimalUpDownEditor();
else if (propertyItem.PropertyType == typeof(double) || propertyItem.PropertyType == typeof(double?))
editor = new DoubleUpDownEditor();
else if (propertyItem.PropertyType == typeof(int) || propertyItem.PropertyType == typeof(int?))
editor = new IntegerUpDownEditor();
else if (propertyItem.PropertyType == typeof(DateTime))

3
ExtendedWPFToolkitSolution/Src/WPFToolkit.Extended/WPFToolkit.Extended.csproj
View File

@ -211,12 +211,13 @@
<Compile Include="PropertyGrid\Implementation\Editors\CustomTypeEditor.cs" />
<Compile Include="PropertyGrid\Implementation\CustomTypeEditorCollection.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\DateTimeUpDownEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\DecimalUpDownEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\DoubleUpDownEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\EnumComboBoxEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\FontComboBoxEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\ICustomTypeEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\IntegerUpDownEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\ITypeEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\NumericUpDownEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\TextBlockEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\TextBoxEditor.cs" />
<Compile Include="PropertyGrid\Implementation\Editors\TypeEditor.cs" />

Write Preview
Loading…
Cancel
Save