mcs/class/referencesource/System.Activities.Core.Presentation/System/Activities/Core/Presentation/CaseKeyBox.xaml.cs

   1 //-----------------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 //-----------------------------------------------------------------------------
   4
   5 namespace System.Activities.Core.Presentation
   6 {
   7     using System;
   8     using System.Activities.Presentation;
   9     using System.Windows;
  10     using System.Windows.Automation;
  11     using System.Windows.Controls;
  12     using System.Windows.Data;
  13     using System.Windows.Input;
  14     using System.Windows.Threading;
  15
  16     partial class CaseKeyBox : UserControl, ICaseKeyBoxView
  17     {
  18         public static readonly DependencyProperty DisplayHintTextProperty =
  19             DependencyProperty.Register("DisplayHintText", typeof(bool), typeof(CaseKeyBox));
  20
  21         public static readonly DependencyProperty LabelTextProperty =
  22           DependencyProperty.Register("LabelText", typeof(string), typeof(CaseKeyBox), new UIPropertyMetadata(string.Empty));
  23
  24         public static readonly DependencyProperty ValueProperty =
  25             DependencyProperty.Register("Value", typeof(object), typeof(CaseKeyBox), new PropertyMetadata(OnValueChanged));
  26
  27         public static readonly DependencyProperty ValueTypeProperty =
  28             DependencyProperty.Register("ValueType", typeof(Type), typeof(CaseKeyBox), new PropertyMetadata(OnValueTypeChanged));
  29
  30         public static readonly DependencyProperty EditorAutomationNameProperty =
  31             DependencyProperty.Register("EditorAutomationName", typeof(string), typeof(CaseKeyBox));
  32
  33         public static readonly DependencyProperty ComboBoxAutomationNameProperty =
  34             DependencyProperty.Register("ComboBoxAutomationName", typeof(string), typeof(CaseKeyBox));
  35
  36         public static RoutedEvent ValueCommittedEvent =
  37             EventManager.RegisterRoutedEvent("ValueCommitted", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(CaseKeyBox));
  38
  39         public static RoutedEvent EditCancelledEvent =
  40             EventManager.RegisterRoutedEvent("EditCancelled", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(CaseKeyBox));
  41
  42         public static readonly DependencyProperty CaseKeyValidationCallbackProperty =
  43             DependencyProperty.Register("CaseKeyValidationCallback", typeof(CaseKeyValidationCallbackDelegate), typeof(CaseKeyBox));
  44
  45         public static readonly DependencyProperty ErrorCallbackProperty =
  46             DependencyProperty.Register("ErrorCallback", typeof(Action<CaseKeyBox>), typeof(CaseKeyBox));
  47
  48         public static readonly DependencyProperty CommitExplicitlyProperty =
  49             DependencyProperty.Register("CommitExplicitly", typeof(bool), typeof(CaseKeyBox), new PropertyMetadata(false));
  50
  51         Control visibleBox;
  52
  53
  54         public CaseKeyBox()
  55         {
  56             this.ViewModel = new CaseKeyBoxViewModel(this);
  57             InitializeComponent();
  58         }
  59
  60         public event RoutedEventHandler ValueCommitted
  61         {
  62             add { AddHandler(ValueCommittedEvent, value); }
  63             remove { RemoveHandler(ValueCommittedEvent, value); }
  64         }
  65
  66         public virtual void OnValueCommitted()
  67         {
  68             RoutedEventArgs args = new RoutedEventArgs();
  69             args.RoutedEvent = ValueCommittedEvent;
  70             RaiseEvent(args);
  71         }
  72
  73         public event RoutedEventHandler EditCancelled
  74         {
  75             add { AddHandler(EditCancelledEvent, value); }
  76             remove { RemoveHandler(EditCancelledEvent, value); }
  77         }
  78
  79         public virtual void OnEditCancelled()
  80         {
  81             RoutedEventArgs args = new RoutedEventArgs();
  82             args.RoutedEvent = EditCancelledEvent;
  83             RaiseEvent(args);
  84         }
  85
  86         public CaseKeyValidationCallbackDelegate CaseKeyValidationCallback
  87         {
  88             get { return (CaseKeyValidationCallbackDelegate)GetValue(CaseKeyValidationCallbackProperty); }
  89             set { SetValue(CaseKeyValidationCallbackProperty, value); }
  90         }
  91
  92         public Action<CaseKeyBox> ErrorCallback
  93         {
  94             get { return (Action<CaseKeyBox>)GetValue(ErrorCallbackProperty); }
  95             set { SetValue(ErrorCallbackProperty, value); }
  96         }
  97
  98         public bool CommitExplicitly
  99         {
 100             get { return (bool)GetValue(CommitExplicitlyProperty); }
 101             set { SetValue(CommitExplicitlyProperty, value); }
 102         }
 103
 104         public string LabelText
 105         {
 106             get { return (string)GetValue(LabelTextProperty); }
 107             set { SetValue(LabelTextProperty, value); }
 108         }
 109
 110         void DisableKeyboardLostFocus()
 111         {
 112             if (this.visibleBox != null)
 113             {
 114                 this.visibleBox.LostKeyboardFocus -= OnLostKeyboardFocus;
 115             }
 116         }
 117
 118         void EnableKeyboardLostFocus()
 119         {
 120             if (!this.CommitExplicitly)
 121             {
 122                 if (this.visibleBox != null)
 123                 {
 124                     this.visibleBox.LostKeyboardFocus += OnLostKeyboardFocus;
 125                 }
 126             }
 127         }
 128
 129         void ReportError(string errorMessage)
 130         {
 131             // Invoking error message box will cause LostFocus of the control.
 132             // Thus we need to disable LostFocus first and then add the handlers back.
 133             DisableKeyboardLostFocus();
 134             ErrorReporting.ShowErrorMessage(errorMessage);
 135
 136             this.Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, (Action)(() =>
 137             {
 138                 if (this.ErrorCallback != null)
 139                 {
 140                     this.ErrorCallback(this);
 141                     this.Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, (Action)(() =>
 142                     {
 143                         RegainFocus();
 144                         EnableKeyboardLostFocus();
 145                     }));
 146                 }
 147                 else
 148                 {
 149                     RegainFocus();
 150                     EnableKeyboardLostFocus();
 151                 }
 152             }));
 153         }
 154
 155         void OnBoxMouseUp(object sender, MouseButtonEventArgs e)
 156         {
 157             // disable the context menu for textbox and combobox
 158             if (e.ChangedButton == MouseButton.Right && e.RightButton == MouseButtonState.Released)
 159             {
 160                 e.Handled = true;
 161             }
 162         }
 163
 164         #region ICaseKeyBoxView Implementation
 165
 166         public bool DisplayHintText
 167         {
 168             get { return (bool)GetValue(DisplayHintTextProperty); }
 169             set { SetValue(DisplayHintTextProperty, value); }
 170         }
 171
 172         public object Value
 173         {
 174             get { return (object)GetValue(ValueProperty); }
 175             set { SetValue(ValueProperty, value); }
 176         }
 177
 178         public Type ValueType
 179         {
 180             get { return (Type)GetValue(ValueTypeProperty); }
 181             set { SetValue(ValueTypeProperty, value); }
 182         }
 183
 184         public string ComboBoxAutomationName
 185         {
 186             get { return (string)GetValue(ComboBoxAutomationNameProperty); }
 187             set { SetValue(ComboBoxAutomationNameProperty, value); }
 188         }
 189
 190         public string EditorAutomationName
 191         {
 192             get { return (string)GetValue(EditorAutomationNameProperty); }
 193             set { SetValue(EditorAutomationNameProperty, value); }
 194         }
 195
 196         public void RegainFocus()
 197         {
 198             if (this.visibleBox != null)
 199             {
 200                 Keyboard.Focus((IInputElement)this.visibleBox);
 201             }
 202         }
 203
 204         #endregion
 205
 206         #region Delegating Event Handlers
 207
 208         public CaseKeyBoxViewModel ViewModel { get; set; }
 209
 210         static void OnValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs eventArgs)
 211         {
 212             ((CaseKeyBox)sender).ViewModel.OnValueChanged();
 213         }
 214
 215         static void OnValueTypeChanged(DependencyObject sender, DependencyPropertyChangedEventArgs eventArgs)
 216         {
 217             ((CaseKeyBox)sender).ViewModel.OnValueTypeChanged();
 218         }
 219
 220         void OnLabelGotFocus(object sender, RoutedEventArgs e)
 221         {
 222             this.ViewModel.OnLabelGotFocus();
 223             e.Handled = true;
 224         }
 225
 226         void OnLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
 227         {
 228             e.Handled = true;
 229
 230             if (ComboBoxHelper.ShouldFilterUnnecessaryComboBoxEvent(sender as ComboBox))
 231             {
 232                 return;
 233             }
 234
 235             CommitChanges();
 236         }
 237
 238         public bool CommitChanges()
 239         {
 240             UpdateSource(this.visibleBox);
 241             if (this.CommitExplicitly || this.ViewModel.TextHasBeenChanged())
 242             {
 243                 string reason = null;
 244                 if (!this.ViewModel.CanResolveInputText(out reason))
 245                 {
 246                     ReportError(reason);
 247                     return false;
 248                 }
 249                 else
 250                 {
 251                     return this.ViewModel.OnLostFocus();
 252                 }
 253             }
 254             else
 255             {
 256                 CancelChanges();
 257                 return false;
 258             }
 259         }
 260
 261         public void CancelChanges()
 262         {
 263             DisableKeyboardLostFocus();
 264             this.ViewModel.OnEscapePressed(); // simulate cancel
 265         }
 266
 267         void OnBoxLoaded(object sender, RoutedEventArgs e)
 268         {
 269             UIElement box = (UIElement)sender;
 270             ComboBox comboBox = box as ComboBox;
 271             if (comboBox != null)
 272             {
 273                 if (!LocalAppContextSwitches.UseLegacyAccessibilityFeatures)
 274                 {
 275                     if (!string.IsNullOrEmpty(ComboBoxAutomationName))
 276                     {
 277                         comboBox.SetValue(AutomationProperties.NameProperty, ComboBoxAutomationName);
 278                     }
 279                     if (comboBox.IsEditable && comboBox.Template != null)
 280                     {
 281                         var comboBoxTextBox = comboBox.Template.FindName("PART_EditableTextBox", comboBox) as TextBox;
 282                         if (comboBoxTextBox != null && !string.IsNullOrEmpty(EditorAutomationName))
 283                         {
 284                             comboBoxTextBox.SetValue(AutomationProperties.NameProperty, EditorAutomationName);
 285                         }
 286                     }
 287                 }
 288
 289                 if (comboBox.IsVisible)
 290                 {
 291                     ComboBoxHelper.SynchronizeComboBoxSelection(comboBox, this.ViewModel.Text);
 292                 }
 293             }
 294
 295             if (!LocalAppContextSwitches.UseLegacyAccessibilityFeatures)
 296             {
 297                 TextBox textBox = box as TextBox;
 298                 if (textBox != null && !string.IsNullOrEmpty(EditorAutomationName))
 299                 {
 300                     textBox.SetValue(AutomationProperties.NameProperty, EditorAutomationName);
 301                 }
 302             }
 303
 304             if (box.IsVisible)
 305             {
 306                 box.Focus();
 307             }
 308             Control control = sender as Control;
 309             if (control != null && control.Visibility == Visibility.Visible)
 310             {
 311                 this.visibleBox = control;
 312                 EnableKeyboardLostFocus();
 313             }
 314
 315             this.ViewModel.SaveOldText();
 316         }
 317
 318         void OnBoxUnloaded(object sender, RoutedEventArgs e)
 319         {
 320             if (this.visibleBox != null)
 321             {
 322                 DisableKeyboardLostFocus();
 323                 this.visibleBox = null;
 324             }
 325         }
 326
 327         void OnBoxKeyDown(object sender, KeyEventArgs e)
 328         {
 329             if (!CommitExplicitly)
 330             {
 331                 if (e.Key == Key.Escape)
 332                 {
 333                     e.Handled = true;
 334                     CancelChanges();
 335                 }
 336                 else if (e.Key == Key.Enter)
 337                 {
 338                     e.Handled = true;
 339                     CommitChanges();
 340                 }
 341             }
 342         }
 343
 344         void UpdateSource(object sender)
 345         {
 346             if (sender is TextBox)
 347             {
 348                 BindingExpression binding = ((TextBox)sender).GetBindingExpression(TextBox.TextProperty);
 349                 if (binding != null)
 350                 {
 351                     binding.UpdateSource();
 352                 }
 353             }
 354             else if (sender is ComboBox)
 355             {
 356                 BindingExpression binding = ((ComboBox)sender).GetBindingExpression(ComboBox.TextProperty);
 357                 if (binding != null)
 358                 {
 359                     binding.UpdateSource();
 360                 }
 361             }
 362         }
 363
 364         #endregion
 365
 366         public void ResetText()
 367         {
 368             this.ViewModel.ResetText();
 369         }
 370     }
 371
 372 }