using System;
|
using System.ComponentModel;
|
using System.Globalization;
|
using System.Windows;
|
using System.Windows.Controls;
|
using System.Windows.Data;
|
using System.Windows.Input;
|
using System.Windows.Media;
|
|
namespace UILib
|
{
|
public enum EditBoxType
|
{
|
String = 0,
|
Bool = 1
|
}
|
|
public class RelayCommand : ICommand
|
{
|
private readonly Action _execute;
|
private readonly Func<bool> _canExecute;
|
|
public RelayCommand(Action execute, Func<bool> canExecute = null)
|
{
|
_execute = execute ?? throw new ArgumentNullException(nameof(execute));
|
_canExecute = canExecute;
|
}
|
|
public event EventHandler CanExecuteChanged
|
{
|
add => CommandManager.RequerySuggested += value;
|
remove => CommandManager.RequerySuggested -= value;
|
}
|
|
public bool CanExecute(object parameter) => _canExecute?.Invoke() ?? true;
|
|
public void Execute(object parameter) => _execute();
|
}
|
|
public class EditBoxConverter : IMultiValueConverter
|
{
|
public static EditBoxConverter Instance = new EditBoxConverter();
|
|
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
|
{
|
if (values[0] is EditBox eb)
|
{
|
if (parameter?.ToString() == "StringFormat")
|
{
|
return eb.EditType == EditBoxType.String && eb.FormatString ? $"\"{values[1]}\"" : values[1]?.ToString();
|
}
|
if (parameter?.ToString() == "BoolIndex")
|
{
|
if (values[1] == null) return null;
|
return string.Equals("true", values[1]?.ToString(), StringComparison.OrdinalIgnoreCase) ? 0 : 1;
|
}
|
}
|
return null;
|
}
|
|
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
|
{
|
return null;
|
}
|
}
|
|
public class EditBox : Control
|
{
|
static EditBox()
|
{
|
DefaultStyleKeyProperty.OverrideMetadata(typeof(EditBox), new FrameworkPropertyMetadata(typeof(EditBox)));
|
}
|
|
public static readonly DependencyProperty EditTypeProperty = DependencyProperty.Register(
|
"EditType",
|
typeof(EditBoxType),
|
typeof(EditBox), new PropertyMetadata(EditBoxType.String));
|
|
public static readonly DependencyProperty FormatStringProperty = DependencyProperty.Register(
|
"FormatString",
|
typeof(bool),
|
typeof(EditBox), new PropertyMetadata(false));
|
|
public static readonly DependencyProperty InitEditProperty = DependencyProperty.Register(
|
"InitEdit",
|
typeof(bool),
|
typeof(EditBox));
|
|
public static readonly DependencyProperty ValueProperty = DependencyProperty.Register(
|
"Value",
|
typeof(object),
|
typeof(EditBox),
|
new FrameworkPropertyMetadata());
|
|
public static readonly DependencyProperty CanEditProperty = DependencyProperty.Register(
|
"CanEdit",
|
typeof(bool),
|
typeof(EditBox),
|
new FrameworkPropertyMetadata(true, new PropertyChangedCallback(OnCanEditPropertyChanged)));
|
|
public static DependencyProperty IsEditingProperty = DependencyProperty.Register(
|
"IsEditing",
|
typeof(bool),
|
typeof(EditBox),
|
new FrameworkPropertyMetadata(false, new PropertyChangedCallback(OnIsEditingPropertyChanged)));
|
|
public static DependencyProperty PreEditingProperty = DependencyProperty.Register(
|
"PreEditing",
|
typeof(Func<EditBox,bool>),
|
typeof(EditBox),
|
new FrameworkPropertyMetadata());
|
|
public static DependencyProperty PreSubmitProperty = DependencyProperty.Register(
|
"PreSubmit",
|
typeof(Func<object, object, object, bool>),
|
typeof(EditBox),
|
new FrameworkPropertyMetadata());
|
|
public static DependencyProperty SubmitedProperty = DependencyProperty.Register(
|
"Submited",
|
typeof(Action<EditBox, object, object>),
|
typeof(EditBox),
|
new FrameworkPropertyMetadata());
|
|
public static DependencyProperty ShowEmptyProperty = DependencyProperty.Register(
|
"ShowEmpty",
|
typeof(bool),
|
typeof(EditBox),
|
new FrameworkPropertyMetadata(false));
|
|
private static void OnCanEditPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
|
{
|
if (obj is EditBox eb && e.Property == CanEditProperty)
|
{
|
bool value = (bool)e.NewValue;
|
//if (value)
|
//{
|
// eb.PreviewMouseDoubleClick += eb.EditBox_MouseDoubleClick;
|
//}
|
//else
|
//{
|
// eb.PreviewMouseDoubleClick -= eb.EditBox_MouseDoubleClick;
|
//}
|
}
|
}
|
|
private static void OnIsEditingPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
|
{
|
if (obj is EditBox eb && e.Property == IsEditingProperty)
|
{
|
bool value = (bool)e.NewValue;
|
|
if (eb.EditType == EditBoxType.String)
|
{
|
eb.editing.Visibility = value ? Visibility.Visible : Visibility.Collapsed;
|
if (value)
|
{
|
eb.editing.Focus();
|
eb.editing.SelectAll();
|
eb.editing.KeyDown += eb.EditBox_KeyDown;
|
}
|
else
|
{
|
eb.editing.KeyDown -= eb.EditBox_KeyDown;
|
}
|
}
|
else if (eb.EditType == EditBoxType.Bool)
|
{
|
|
eb.editingComboBox.Visibility = value ? Visibility.Visible : Visibility.Collapsed;
|
if (value)
|
{
|
eb.editingComboBox.Focus();
|
eb.editingComboBox.IsDropDownOpen = true;
|
eb.editingComboBox.KeyDown += eb.EditBox_KeyDown;
|
}
|
else
|
{
|
eb.editingComboBox.KeyDown -= eb.EditBox_KeyDown;
|
}
|
}
|
}
|
}
|
|
private static void OnInitEditPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
|
{
|
if (obj is EditBox eb && e.Property == InitEditProperty)
|
{
|
bool value = (bool)e.NewValue;
|
if (eb.editing != null || !value)
|
{
|
return;
|
}
|
if (value)
|
{
|
|
}
|
}
|
}
|
|
public bool FormatString
|
{
|
get => (bool)GetValue(FormatStringProperty);
|
set
|
{
|
SetValue(FormatStringProperty, value);
|
}
|
}
|
|
public EditBoxType EditType
|
{
|
get => (EditBoxType)GetValue(EditTypeProperty);
|
set
|
{
|
SetValue(EditTypeProperty, value);
|
}
|
}
|
public TextBox editing { get; private set; }
|
private ComboBox editingComboBox;
|
public EditBox()
|
{
|
this.MouseDoubleClick += EditBox_MouseDoubleClick;
|
//if (CanEdit)
|
//{
|
|
//}
|
this.InputBindings.Add(new KeyBinding(
|
new RelayCommand(() => TryEdit(null)),
|
Key.F2,
|
ModifierKeys.None
|
));
|
this.Loaded += EditBox_Loaded;
|
}
|
|
private void EditBox_Loaded(object sender, RoutedEventArgs e)
|
{
|
//var control = this.Template.FindName("PART_TextBoxPart", this) as ContentControl;
|
//editing = control.Content as FrameworkElement;
|
if (EditType == EditBoxType.String)
|
{
|
editing = this.Template.FindName("PART_TextBoxPart", this) as TextBox;
|
}
|
else
|
{
|
editingComboBox = this.Template.FindName("PART_ComboBoxPart", this) as ComboBox;
|
}
|
//editing = control.Content as FrameworkElement;
|
}
|
|
private void EditBox_MouseDoubleClick(object sender, MouseButtonEventArgs e)
|
{
|
TryEdit(e);
|
}
|
|
public void TryEdit(MouseButtonEventArgs e)
|
{
|
if (!CanEdit)
|
{
|
return;
|
}
|
|
if (IsEditing)
|
{
|
return;
|
}
|
|
Func<EditBox, bool> pre = GetValue(PreEditingProperty) as Func<EditBox,bool>;
|
if (pre != null && pre.Invoke(this) != true)
|
{
|
return;
|
}
|
var win = Window.GetWindow(this);
|
|
win.MouseDown += Win_MouseDown;
|
if (EditType == EditBoxType.String)
|
{
|
editing.Focus();
|
//editing.LostFocus += TextBox_LostFocus;
|
this.LostFocus += EditBox_LostFocus;
|
}
|
else
|
{
|
editingComboBox.DropDownClosed += EditingComboBox_DropDownClosed;
|
}
|
IsEditing = true;
|
if (e != null)
|
{
|
e.Handled = true;
|
}
|
}
|
|
private void EditingComboBox_DropDownClosed(object sender, EventArgs e)
|
{
|
CancelEditing(sender);
|
}
|
|
public static bool GetElementUnderMouse(UIElement relativeTo, UIElement target)
|
{
|
Point mousePosition = Mouse.GetPosition(relativeTo);
|
bool res = false;
|
HitTestResultCallback resultCallback = (result) =>
|
{
|
// 获取相交的UI元素
|
var element = result.VisualHit as FrameworkElement;
|
|
if (element != null && element == target)
|
{
|
res = true;
|
return HitTestResultBehavior.Stop; // 找到后停止遍历
|
}
|
return HitTestResultBehavior.Continue;
|
};
|
|
VisualTreeHelper.HitTest(relativeTo, null,
|
resultCallback, new PointHitTestParameters(mousePosition));
|
return res;
|
}
|
|
private void EditBox_LostFocus(object sender, RoutedEventArgs e)
|
{
|
CancelEditing(sender);
|
}
|
|
private void TextBox_LostFocus(object sender, RoutedEventArgs e)
|
{
|
CancelEditing(sender);
|
}
|
|
private void Win_MouseDown(object sender, RoutedEventArgs e)
|
{
|
CancelEditing(sender);
|
}
|
|
private void EditBox_KeyDown(object sender, KeyEventArgs e)
|
{
|
if (e.Key == Key.Enter)
|
{
|
CancelEditing(sender);
|
}
|
}
|
|
private void CancelEditing(object sender)
|
{
|
if (EditType == EditBoxType.String)
|
{
|
if (PreSubmit != null && !PreSubmit.Invoke(this, editing.Text, DataContext))
|
{
|
editing.Text = Value?.ToString();
|
|
Dispatcher.BeginInvoke(new Action(() =>
|
{
|
editing.Focus();
|
}), System.Windows.Threading.DispatcherPriority.Input);
|
//editing.LostFocus += TextBox_LostFocus;
|
return;
|
}
|
}
|
|
if (EditType == EditBoxType.String)
|
{
|
IsEditing = false;
|
this.LostFocus -= EditBox_LostFocus;
|
editing.LostFocus -= TextBox_LostFocus;
|
Window.GetWindow(this).MouseDown -= Win_MouseDown;
|
}
|
else if (EditType == EditBoxType.Bool)
|
{
|
IsEditing = false;
|
editingComboBox.DropDownClosed -= EditingComboBox_DropDownClosed;
|
Window.GetWindow(this).MouseDown -= Win_MouseDown;
|
}
|
else
|
{
|
var win = sender as Window;
|
if (!GetElementUnderMouse(win, this))
|
{
|
//editing.Focu
|
IsEditing = false;
|
win.MouseDown -= Win_MouseDown;
|
Window.GetWindow(this).MouseDown -= Win_MouseDown;
|
}
|
}
|
Submited?.Invoke(this, null, null);
|
}
|
|
[Bindable(true)]
|
[Category("Appearance")]
|
public object Value
|
{
|
get { return GetValue(ValueProperty); }
|
set { SetValue(ValueProperty, value); }
|
}
|
|
public bool CanEdit
|
{
|
get => (bool)GetValue(CanEditProperty);
|
set
|
{
|
SetValue(CanEditProperty, value);
|
}
|
}
|
|
public bool IsEditing
|
{
|
get => (bool)GetValue(IsEditingProperty);
|
set
|
{
|
SetValue(IsEditingProperty, value);
|
}
|
}
|
|
public Func<EditBox, bool> PreEditing
|
{
|
get => (Func<EditBox, bool>)GetValue(PreEditingProperty);
|
set
|
{
|
SetValue(PreEditingProperty, value);
|
}
|
}
|
|
public Func<object, object, object, bool> PreSubmit
|
{
|
get => (Func<object, object, object, bool>)GetValue(PreSubmitProperty);
|
set
|
{
|
SetValue(PreSubmitProperty, value);
|
}
|
}
|
|
public Action<EditBox, object, object> Submited
|
{
|
get => (Action<EditBox, object, object>)GetValue(SubmitedProperty);
|
set
|
{
|
SetValue(SubmitedProperty, value);
|
}
|
}
|
|
public bool ShowEmpty
|
{
|
get => (bool)GetValue(ShowEmptyProperty);
|
set
|
{
|
SetValue(ShowEmptyProperty, value);
|
}
|
}
|
|
public bool InitEdit
|
{
|
get => (bool)GetValue(InitEditProperty);
|
set
|
{
|
SetValue(InitEditProperty, value);
|
}
|
}
|
}
|
}
|
