Category

Development Platform
Home > SourceCode/Document > Windows Develop > CSharp > View Code
CellEditor.cs
Package: DXperience9.3.2.rar　[view]
Upload User: linjidu
Upload Date: 2021-04-29
Package Size: 49798k
Code Size: 31k
Category:

CSharp

Development Platform:

C#

CellEditor.cs：Code Content
  1. #region Copyright (c) 2000-2009 Developer Express Inc.
  2. /*
  3. {*******************************************************************}
  4. {                                                                   }
  5. {       Developer Express .NET Component Library                    }
  6. {       DXGrid                                 }
  7. {                                                                   }
  8. {       Copyright (c) 2000-2009 Developer Express Inc.              }
  9. {       ALL RIGHTS RESERVED                                         }
  10. {                                                                   }
  11. {   The entire contents of this file is protected by U.S. and       }
  12. {   International Copyright Laws. Unauthorized reproduction,        }
  13. {   reverse-engineering, and distribution of all or any portion of  }
  14. {   the code contained in this file is strictly prohibited and may  }
  15. {   result in severe civil and criminal penalties and will be       }
  16. {   prosecuted to the maximum extent possible under the law.        }
  17. {                                                                   }
  18. {   RESTRICTIONS                                                    }
  19. {                                                                   }
  20. {   THIS SOURCE CODE AND ALL RESULTING INTERMEDIATE FILES           }
  21. {   ARE CONFIDENTIAL AND PROPRIETARY TRADE                          }
  22. {   SECRETS OF DEVELOPER EXPRESS INC. THE REGISTERED DEVELOPER IS   }
  23. {   LICENSED TO DISTRIBUTE THE PRODUCT AND ALL ACCOMPANYING .NET    }
  24. {   CONTROLS AS PART OF AN EXECUTABLE PROGRAM ONLY.                 }
  25. {                                                                   }
  26. {   THE SOURCE CODE CONTAINED WITHIN THIS FILE AND ALL RELATED      }
  27. {   FILES OR ANY PORTION OF ITS CONTENTS SHALL AT NO TIME BE        }
  28. {   COPIED, TRANSFERRED, SOLD, DISTRIBUTED, OR OTHERWISE MADE       }
  29. {   AVAILABLE TO OTHER INDIVIDUALS WITHOUT EXPRESS WRITTEN CONSENT  }
  30. {   AND PERMISSION FROM DEVELOPER EXPRESS INC.                      }
  31. {                                                                   }
  32. {   CONSULT THE END USER LICENSE AGREEMENT FOR INFORMATION ON       }
  33. {   ADDITIONAL RESTRICTIONS.                                        }
  34. {                                                                   }
  35. {*******************************************************************}
  36. */
  37. #endregion Copyright (c) 2000-2009 Developer Express Inc.
  39. using System.Windows;
  40. using DevExpress.Wpf.Core;
  41. using System.Windows.Media;
  42. using System.ComponentModel;
  43. using System.Windows.Input;
  44. using System.Globalization;
  45. using System.Windows.Controls;
  46. using System;
  47. using DevExpress.Wpf.Editors;
  48. using System.Windows.Data;
  49. using DevExpress.Wpf.Core.Native;
  50. using DevExpress.XtraEditors.DXErrorProvider;
  51. using DevExpress.Wpf.Editors.Helpers;
  52. using DevExpress.Wpf.Editors.Settings;
  53. using DevExpress.Wpf.Editors.Validation;
  54. using DevExpress.Wpf.Utils.Themes;
  55. using DevExpress.Wpf.Data;
  56. using System.Collections.Generic;
  57. using System.Collections;
  58. using DevExpress.Wpf.Editors.Native;
  59. namespace DevExpress.Wpf.Grid {
  60. public abstract class CellEditorBase : DataContentPresenter, IWeakEventListener, IDisplayTextProvider {
  61. protected enum BaseEditSourceType { EditSettings, CellTemplate }
  62. const int EscCode = 27;
  63. public static readonly DependencyProperty FieldNameProperty;
  64. public static readonly DependencyProperty ColumnProperty;
  65. static CellEditorBase() {
  66. FocusableProperty.OverrideMetadata(typeof(CellEditorBase), new FrameworkPropertyMetadata(true));
  67. FieldNameProperty = DependencyProperty.Register("FieldName", typeof(string), typeof(CellEditorBase), new FrameworkPropertyMetadata(null, (d, e) => ((CellEditorBase)d).OnFieldNameChanged()));
  68. ColumnProperty = DependencyProperty.Register("Column", typeof(GridColumn), typeof(CellEditorBase), new FrameworkPropertyMetadata(null, (d, e) => ((CellEditorBase)d).OnColumnChanged((GridColumn)e.OldValue)));
  69. TableView.IsFocusedCellProperty.OverrideMetadata(typeof(CellEditorBase), new FrameworkPropertyMetadata((d, e) => ((CellEditorBase)d).OnIsFocusedCellChanged()));
  70. GridColumn.NavigationIndexProperty.AddOwner(typeof(CellEditorBase));
  71. }
  72. static bool GetIsEditorButtonVisible(EditorButtonShowMode editorShowMode, bool isFocusedCell, bool isFocusedRow, bool isEditorVisible) {
  73. switch(editorShowMode) {
  74. case EditorButtonShowMode.ShowAlways:
  75. return true;
  76. case EditorButtonShowMode.ShowOnlyInEditor:
  77. return isEditorVisible;
  78. case EditorButtonShowMode.ShowForFocusedRow:
  79. return isFocusedRow;
  80. default:
  81. return isFocusedCell;
  82. }
  83. }
  84. public string FieldName {
  85. get { return (string)GetValue(FieldNameProperty); }
  86. set { SetValue(FieldNameProperty, value); }
  87. }
  88. public GridColumn Column {
  89. get { return (GridColumn)GetValue(ColumnProperty); }
  90. set { SetValue(ColumnProperty, value); }
  91. }
  92. public int NavigationIndex {
  93. get { return (int)GetValue(GridColumn.NavigationIndexProperty); }
  94. set { SetValue(GridColumn.NavigationIndexProperty, value); }
  95. }
  96. public bool IsEditorVisible { get { return Edit.EditMode == EditMode.InplaceActive; } }
  97. internal void LockEditorFocus() { Edit.LockEditorFocus(); }
  98. internal void UnlockEditorFocus() { Edit.UnlockEditorFocus(); }
  99. protected BaseEditSourceType EditorSourceType { get; private set; }
  100. protected BaseEdit editCore;
  101. IBaseEdit editWrapper;
  102. EditGridCellData cellData;
  103. internal virtual bool IsInTree { get { return View != null; } }
  104. protected virtual bool IsRowFocused { get { return RowHandle == View.FocusedRowHandle; } }
  105. protected bool HasAccessToCellValue { get { return IsInTree && Column != null; } }
  106. internal object EditableValue { get { return Edit.EditValue; } set { Edit.EditValue = value; } }
  107. internal GridViewBase View { get { return GridControl.GetActiveView(this); } }
  108. protected GridControl Grid { get { return View.Grid; } }
  109. protected abstract int RowHandle { get; }
  110. protected abstract bool IsReadOnly { get; }
  111. internal RowData RowData { get { return RowData.GetRowData(this); } }
  112. protected abstract bool OverrideCellTemplate { get; }
  113. protected string FieldNameCore { get { return Column.FieldName; } }
  114. protected IBaseEdit Edit { get { return editWrapper != null ? editWrapper : FakeBaseEdit.Instance; } }
  115. protected virtual EditGridCellData CellData {
  116. get { return cellData; }
  117. set {
  118. if(CellData == value)
  119. return;
  120. if(CellData != null) {
  121. CellData.ContentChanged -= new EventHandler(OnInnerContentChanged);
  122. if(CellData.CellEditor == this)
  123. CellData.CellEditor = null;
  124. }
  125. cellData = value;
  126. if(CellData != null) {
  127. CellData.ContentChanged += new EventHandler(OnInnerContentChanged);
  128. CellData.CellEditor = this;
  129. }
  130. }
  131. }
  132. protected internal bool IsChildElement(IInputElement element) {
  133. return Edit.IsChildElement(element);
  134. }
  135. void SetEdit(BaseEdit value) {
  136. if(editCore == value)
  137. return;
  138. if(editCore != null) {
  139. editCore.EditorActivated -= new RoutedEventHandler(OnEditorActivated);
  140. editCore.PreviewLostKeyboardFocus -= new KeyboardFocusChangedEventHandler(OnEditorPreviewLostKeyboardFocus);
  141. }
  142. editCore = value;
  143. editWrapper = editCore != null ? new BaseEditWrapper(editCore) : null;
  144. if(editCore != null) {
  145. editCore.EditorActivated += new RoutedEventHandler(OnEditorActivated);
  146. editCore.PreviewLostKeyboardFocus += new KeyboardFocusChangedEventHandler(OnEditorPreviewLostKeyboardFocus);
  147. }
  148. }
  149. bool IsCellFocused { 
  150. get {
  151. return TableView.GetIsFocusedCell(this); 
  152. } 
  153. }
  154. protected virtual void OnColumnContentChanged(object sender, ColumnContentChangedEventArgs e) {
  155. if(e.Property == GridColumn.DisplayTemplateProperty) {
  156. UpdateDisplayTemplate();
  157. return;
  158. }
  159. if(e.Property == null)
  160. UpdateContent();
  161. }
  162. internal Locker SetKeyboardFocusToEditorLocker { get { return View.SetKeyboardFocusToEditorLocker; } }
  163. protected CellEditorBase() {
  164. }
  165. protected virtual void UpdateEditContext() {
  166. if(HasAccessToCellValue)
  167. EditableValue = Grid.GetCellValue(RowHandle, FieldNameCore);
  168. }
  169. internal void ActivateOnLeftMouseButton(MouseButtonEventArgs e, bool isMouseDown) {
  170. if(IsCellFocused) {
  171. if(!Edit.IsEditorActive) {
  172. ShowEditorIfNotVisible(!isMouseDown);
  173. if(IsEditorVisible && isMouseDown) {
  174. View.DataPresenter.EnqueueImmediateAction(new RaisePostponedMouseEventAction(this, e));
  175. e.Handled = true;
  176. }
  177. }
  178. }
  179. }
  180. protected override void OnPreviewTextInput(TextCompositionEventArgs e) {
  181. base.OnPreviewTextInput(e);
  182. if(string.IsNullOrEmpty(e.Text) || !string.IsNullOrEmpty(e.ControlText) || !string.IsNullOrEmpty(e.SystemText) || (int)e.Text[0] == EscCode)
  183. return;
  184. if(!IsEditorVisible)
  185. ShowEditorAndSelectAll();
  186. if(IsEditorVisible && !Edit.IsEditorActive) {
  187. View.DataPresenter.EnqueueImmediateAction(new RaisePostponedTextInputEventAction(this, e));
  188. e.Handled = true;
  189. }
  190. }
  191. internal void ProcessActivatingKey(KeyEventArgs e) {
  192. Edit.ProcessActivatingKey(e);
  193. }
  194. protected override void OnPreviewKeyDown(KeyEventArgs e) {
  195. base.OnPreviewKeyDown(e);
  196. if(!IsEditorVisible && Edit.IsActivatingKey(e)) {
  197. ShowEditorAndSelectAll();
  198. if(IsEditorVisible) {
  199. View.DataPresenter.EnqueueImmediateAction(new ProcessActivatingKeyAction(this, e));
  200. e.Handled = true;
  201. } else {
  202. RaiseKeyDownEvent(e);
  203. }
  204. return;
  205. }
  206. if(!Edit.NeedsKey(e)) {
  207. if(e.Key == Key.Enter) {
  208. if(IsEditorVisible) {
  209. CommitEditor();
  210. View.EditorWasClosed = true;
  211. } else {
  212. ShowEditorAndSelectAll();
  213. }
  214. e.Handled = true;
  215. }
  216. if(e.Key == Key.F2) {
  217. if(!IsEditorVisible) {
  218. ShowEditorAndSelectAll();
  219. e.Handled = true;
  220. }
  221. }
  222. if(e.Key == Key.Escape) {
  223. if(IsEditorVisible) {
  224. CancelEditInVisibleEditor();
  225. e.Handled = true;
  226. }
  227. else
  228. CancelRowEdit();
  229. }
  230. if(!e.Handled) {
  231. RaiseKeyDownEvent(e);
  232. }
  233. }
  234. }
  235. internal void CancelEditInVisibleEditor() {
  236. if(!IsEditorVisible)
  237. return;
  238. RestoreValidationError();
  239. HideEditor();
  240. View.EditorWasClosed = true;
  241. }
  242. protected virtual void CancelRowEdit() {
  243. }
  244. protected virtual void RestoreValidationError() { 
  245. }
  246. void RaiseKeyDownEvent(KeyEventArgs e) {
  247. e.Handled = true;
  248. View.ProcessKeyDown(e);
  249. }
  250. internal void ShowEditor() {
  251. ShowEditor(false);
  252. }
  253. internal void ShowEditor(bool selectAll) {
  254. if(!CanShowEditor())
  255. return;
  256. if(!IsEditorVisible) {
  257. UpdateEditTemplate();
  258. Edit.IsReadOnly = IsReadOnly;
  259. Edit.EditMode = EditMode.InplaceActive;
  260. View.SetActiveEditor(editCore);
  261. Edit.SetKeyboardFocus();
  262. UpdateEditContext();
  263. Edit.EditValueChanged += new EditValueChangedEventHandler(OnEditValueChanged);
  264. }
  265. View.OnShowEditor();
  266. View.EditorWasClosed = false;
  267. UpdateEditorButtonVisibility();
  268. Edit.IsValueChanged = false;
  269. if(selectAll)
  270. View.DataPresenter.EnqueueImmediateAction(new SelectAllAction(this));
  271. }
  272. void OnEditValueChanged(object sender, EditValueChangedEventArgs e) {
  273. View.RaiseCellValueChanging(new CellValueChangedEventArgs(View, RowHandle, Column, Edit.EditValue, e.OldValue) { RoutedEvent = TableView.CellValueChangingEvent });
  274. OnEditValueChanged();
  275. }
  276. protected virtual void OnEditValueChanged() {
  277. }
  278. internal void ShowEditorIfNotVisible(bool selectAll) {
  279. if(!IsEditorVisible)
  280. ShowEditor(selectAll);
  281. }
  282. internal void ShowEditorAndSelectAll() {
  283. ShowEditor(true);
  284. }
  285. protected internal virtual bool CanShowEditor() {
  286. return IsCellFocused && RaiseShowingEditor();
  287. }
  288. bool RaiseShowingEditor() {
  289. ShowingEditorEventArgs e = new ShowingEditorEventArgs(View, RowHandle, Column);
  290. View.RaiseShowingEditor(e);
  291. return !e.Cancel;
  292. }
  293. internal void CommitEditor() {
  294. if(!IsEditorVisible)
  295. return;
  296. if(PostEditor())
  297. HideEditor();
  298. }
  299. protected internal virtual bool PostEditor() {
  300. return true;
  301. }
  302. protected internal virtual void ValidateEditor() {
  303. }
  304. internal void HideEditor() {
  305. if(IsEditorVisible) {
  306. Edit.EditMode = EditMode.InplaceInactive;
  307. Edit.EditValueChanged -= new EditValueChangedEventHandler(OnEditValueChanged);
  308. if(View.ActiveEditor == editCore)
  309. View.SetActiveEditor(null);
  310. OnHiddenEditor();
  311. }
  312. }
  313. protected virtual void OnHiddenEditor() {
  314. UpdateEditorButtonVisibility();
  315. View.OnHideEditor();
  316. View.RaiseHiddenEditor(new EditorEventArgs(View, RowHandle, Column, editCore) { RoutedEvent = TableView.HiddenEditorEvent });
  317. }
  318. void OnIsFocusedCellChanged() {
  319. if(IsCellFocused) {
  320. if(View.IsKeyboardFocusWithin) {
  321. Edit.SetKeyboardFocus();
  322. if(!IsKeyboardFocusWithin)
  323. Keyboard.Focus(this);
  324. }
  325. UpdateEditorToShow();
  326. }
  327. else {
  328. if(IsEditorVisible)
  329. CommitEditor();
  330. if(IsInTree) {
  331. if(IsKeyboardFocusWithin)
  332. Keyboard.Focus(View);
  333. ClearViewCurrentCellEditor(View);
  334. }
  335. }
  336. UpdateEditorButtonVisibility();
  337. }
  338. protected void ClearViewCurrentCellEditor(GridViewBase view) {
  339. if(view.CurrentCellEditor == this)
  340. view.CurrentCellEditor = null;
  341. }
  342. void UpdateEditorToShow() {
  343. if(IsCellFocused) {
  344. View.CurrentCellEditor = this;
  345. }
  346. }
  347. #if DEBUGTEST
  348. internal int InnerContentChangedFireCount { get; set; }
  349. #endif
  350. protected override void OnInnerContentChangedCore() {
  351. base.OnInnerContentChangedCore();
  352. #if DEBUGTEST            
  353. InnerContentChangedFireCount++;
  354. #endif
  355. if(!IsInTree)
  356. return;
  357. UpdateContent();
  358. UpdateEditorButtonVisibility();
  359. UpdateValidationError();
  360. }
  361. void OnColumnChanged(GridColumn oldValue) {
  362. UpdateData();
  363. if(oldValue != null) {
  364. ContentChangedEventManager.RemoveListener(oldValue, this);
  365. }
  366. if(Column != null) {
  367. ContentChangedEventManager.AddListener(Column, this);
  368. UpdateContent();
  369. }
  370. }
  371. void OnFieldNameChanged() {
  372. if(Column == null && FieldName != null)
  373. Column = View.Columns[FieldName];
  374. }
  375. protected virtual void UpdateData() {
  376. if(HasAccessToCellValue) {
  377. CellData = (EditGridCellData)RowData.GetCellDataByColumn(Column);
  378. } else {
  379. CellData = null;
  380. Content = null;
  381. }
  382. }
  383. protected void UpdateContent() {
  384. if(!IsInTree)
  385. return;
  386. if(Column.ActualCellTemplateSelector.SelectTemplate(CellData, this) == null || OverrideCellTemplate) {
  387. if(editCore == null || !IsProperEditorSettings()) {
  388. BaseEdit newEdit = CreateEditor(Column.ActualEditSettings);
  389. newEdit.DataContext = CellData;
  390. InitializeBaseEdit(newEdit, BaseEditSourceType.EditSettings);
  391. ContentTemplateSelector = null;
  392. Content = newEdit;
  393. } else {
  394. if(!object.ReferenceEquals(BaseEditHelper.GetEditSettings(editCore), Column.ActualEditSettings)) {
  395. Column.ActualEditSettings.ApplyToEdit(editCore, true, Column);
  396. editCore.DataContext = CellData;
  397. }
  398. }
  399. } else {
  400. Content = CellData;
  401. ContentTemplateSelector = Column.ActualCellTemplateSelector;
  402. if(EditorSourceType == BaseEditSourceType.EditSettings)
  403. SetEdit(null);
  404. }
  405. }
  406. protected virtual bool IsProperEditorSettings() {
  407. return object.ReferenceEquals(BaseEditHelper.GetEditSettings(editCore), Column.ActualEditSettings);
  408. }
  409. protected virtual BaseEdit CreateEditor(BaseEditSettings settings){
  410. return settings.CreateEditor(Column);
  411. }
  412. public override void OnApplyTemplate() {
  413. base.OnApplyTemplate();
  414. BaseEdit editFromTemplate = GetTemplateChild("PART_Editor") as BaseEdit;
  415. if(editFromTemplate != null)
  416. InitializeBaseEdit(editFromTemplate, BaseEditSourceType.CellTemplate);
  417. }
  418. void InitializeBaseEdit(BaseEdit newEdit, BaseEditSourceType newBaseEditSourceType) {
  419. this.EditorSourceType = newBaseEditSourceType;
  420. newEdit.EditMode = EditMode.InplaceInactive;
  421. UpdateEditValue(newEdit);
  422. SetEdit(newEdit);
  423. UpdateEditorButtonVisibility();
  424. UpdateDisplayTemplate();
  425. UpdateValidationError();
  426. SetDisplayTextProvider(newEdit);
  427. }
  428. protected virtual void SetDisplayTextProvider(BaseEdit newEdit) {
  429. BaseEditHelper.SetDisplayTextProvider(newEdit, this);
  430. }
  431. protected virtual void UpdateEditValue(BaseEdit editor) {
  432. editor.SetBinding(BaseEdit.EditValueProperty, new Binding(GridCellData.ValueProperty.Name) { Mode = BindingMode.TwoWay, UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged });
  433. }
  434. protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParameters) {
  435. HitTestResult result = base.HitTestCore(hitTestParameters);
  436. return result == null ? new PointHitTestResult(this, hitTestParameters.HitPoint) : result;
  437. }
  438. void OnEditorPreviewLostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e) {
  439. if(!IsInTree || Edit.IsChildElement(e.NewFocus)) {
  440. return;
  441. }
  442. if(IsEditorVisible && Edit.IsEditorActive) {
  443. SetKeyboardFocusToEditorLocker.DoLockedAction(() => CommitEditor());
  444. }
  445. if(View.HasCellEditorError)
  446. e.Handled = true;
  447. }
  448. void OnEditorActivated(object sender, RoutedEventArgs e) {
  449. View.RaiseShownEditor(new EditorEventArgs(View, RowHandle, Column, editCore));
  450. }
  451. internal void UpdateEditorButtonVisibility() {
  452. if(!IsInTree)
  453. return;
  454. Edit.IsEditButtonsVisible = GetIsEditorButtonVisible(View.EditorButtonShowMode, TableView.GetIsFocusedCell(this), IsRowFocused, IsEditorVisible);
  455. }
  456. protected virtual void UpdateEditTemplate() {
  457. Edit.SetEditTemplate(Column.EditTemplate);
  458. }
  459. protected virtual void UpdateDisplayTemplate() {
  460. Edit.SetDisplayTemplate(Column.DisplayTemplate);
  461. }
  462. protected virtual void UpdateValidationError() {
  463. }
  464. internal void SelectAll() {
  465. Edit.SelectAll();
  466. }
  467. #region IWeakEventListener Members
  468. bool IWeakEventListener.ReceiveWeakEvent(Type managerType, object sender, EventArgs e) {
  469. if(managerType == typeof(ContentChangedEventManager)) {
  470. OnColumnContentChanged(sender, (ColumnContentChangedEventArgs)e);
  471. return true;
  472. }
  473. return false;
  474. }
  475. #endregion
  476. #region IDisplayTextProvider Members
  477. string IDisplayTextProvider.GetDisplayText(string originalDisplayText) {
  478. if(!IsInTree)
  479. return originalDisplayText;
  480. return View.Grid.RaiseCustomDisplayText(RowHandle, Column, Edit.EditValue, originalDisplayText);
  481. }
  482. #endregion
  483. }
  484. public class CellEditor : CellEditorBase {
  485. static CellEditor() {
  486. DefaultStyleKeyProperty.OverrideMetadata(typeof(CellEditor), new FrameworkPropertyMetadata(typeof(CellEditor)));
  487. RowData.RowDataProperty.OverrideMetadata(typeof(CellEditor), new FrameworkPropertyMetadata((d, e) => ((CellEditor)d).OnRowDataChanged((RowData)e.OldValue)));
  488. }
  489. public CellEditor() {
  490. }
  491. internal override bool IsInTree { get { return base.IsInTree && RowData != null; } }
  492. protected override int RowHandle { get { return RowData.RowHandle != null ? RowData.RowHandle.Value : GridControl.InvalidRowHandle; } }
  493. protected override bool IsReadOnly { get { return Column.ReadOnly || View.DataProvider.IsColumnReadonly(Column.FieldName); } }
  494. protected override bool OverrideCellTemplate { get { return false; } }
  495. protected internal override bool CanShowEditor() {
  496. return Column.GetAllowEditing() && base.CanShowEditor();
  497. }
  498. protected internal override bool PostEditor() {
  499. if(Edit.IsValueChanged) {
  500. ValidateEditor();
  501. if(View.HasCellEditorError) {
  502. return false;
  503. }
  504. if(HasAccessToCellValue) {
  505. try {
  506. Grid.SetCellValue(RowData.RowHandle.Value, FieldNameCore, EditableValue);
  507. } catch(Exception e) {
  508. ShowError(new GridCellValidationError(e.Message, e, ErrorType.Default, RowData.RowHandle.Value, Column));
  509. return false;
  510. }
  511. RowData.UpdateData();
  512. }
  513. }
  514. return true;
  515. }
  516. protected internal override void ValidateEditor() {
  517. if(IsEditorVisible) {
  518. Edit.FlushPendingEditActions();
  519. ShowError(GetValidationError());
  520. }
  521. }
  522. protected override void OnHiddenEditor() {
  523. CellData.UpdateValue();
  524. base.OnHiddenEditor();
  525. }
  526. protected override void CancelRowEdit() {
  527. View.DataProvider.CancelCurrentRowEdit();
  528. View.OnCancelRowEdit();
  529. View.Grid.SetRowStateError(RowData.RowHandle.Value, null);
  530. }
  531. protected override void OnEditValueChanged() {
  532. base.OnEditValueChanged();
  533. View.OnFocusedRowCellModified();
  534. }
  535. void ShowError(GridCellValidationError validationError) {
  536. SetValidationError(null);
  537. if(validationError != null)
  538. SetValidationError(validationError);
  539. else
  540. RestoreValidationError();
  541. }
  542. GridCellValidationError GetValidationError() {
  543. ValidationResult validationResult;
  544. Exception exception = null;
  545. if(!Edit.DoValidate())
  546. return new GridCellValidationError("Invalid Value", null, ErrorType.Default, RowData.RowHandle.Value, Column);
  547. GridCellValidationEventArgs eventArgs = new GridCellValidationEventArgs(BaseEdit.ValidateEvent, this, EditableValue, CultureInfo.CurrentCulture, RowData.RowHandle.Value, View, Column);
  548. try {
  549. Column.OnValidation(eventArgs);
  550. validationResult = new ValidationResult(eventArgs.IsValid, eventArgs.ErrorContent);
  551. } catch(Exception e) {
  552. exception = e;
  553. validationResult = new ValidationResult(false, e.Message);
  554. }
  555. return validationResult.IsValid ? null : new GridCellValidationError(
  556. validationResult.ErrorContent,
  557. exception,
  558. eventArgs.ErrorType == ErrorType.None ? ErrorType.Default : eventArgs.ErrorType,
  559. RowData.RowHandle.Value,
  560. Column
  561. );
  562. }
  563. void SetValidationError(GridCellValidationError validationError) {
  564. View.ValidationError = validationError;
  565. BaseEditHelper.SetValidationError(RowData, validationError);
  566. BaseEditHelper.SetValidationError(CellData, validationError);
  567. Edit.SetValidationError(validationError);
  568. RowData.UpdateIndicatorState();
  569. }
  570. protected override void RestoreValidationError() {
  571. View.ValidationError = null;
  572. RowData.UpdateDataErrors();
  573. }
  574. protected override void UpdateValidationError() {
  575. Edit.SetValidationError(BaseEdit.GetValidationError(CellData));
  576. }
  577. void OnRowDataChanged(RowData oldValue) {
  578. UpdateData();
  579. if(!IsInTree)
  580. if(oldValue != null)
  581. ClearViewCurrentCellEditor(oldValue.View);
  582. }
  583. protected override bool IsProperEditorSettings() {
  584. return EditSettingsComparer.IsCompatibleEditSettings(editCore, Column.ActualEditSettings);
  585. }
  586. protected override void OnContentInvalidated() {
  587. base.OnContentInvalidated();
  588. if(editCore != null && EditorSourceType == BaseEditSourceType.CellTemplate)
  589. editCore.ClearValue(BaseEdit.EditValueProperty);
  590. }
  591. }
  592. public class FilterRowCellEditor : CellEditorBase {
  593. public FilterRowCellEditor() : base() {
  594. TableView.SetRowHandle(this, new RowHandle(RowHandle));
  595. }
  596. protected override int RowHandle { get { return GridControl.AutoFilterRowHandle; } }
  597. protected override bool IsReadOnly { get { return !Column.AllowAutoFilter; } }
  598. protected override bool OverrideCellTemplate { get { return true; } }
  599. protected override void UpdateEditContext() {
  600. }
  601. protected override void UpdateDisplayTemplate() {
  602. }
  603. protected override void UpdateEditTemplate() {
  604. }
  605. protected override BaseEdit CreateEditor(BaseEditSettings settings) {
  606. CheckEditSettings checkEditSettings = settings as CheckEditSettings;
  607. if(checkEditSettings != null) {
  608. CheckEdit checkEdit = (CheckEdit)checkEditSettings.CreateEditor(false, EmptyDefaultEditorViewInfo.Instance);
  609. checkEdit.IsThreeState = true;
  610. checkEdit.IsChecked = null;
  611. return checkEdit;
  612. }
  613. if(Column.ColumnFilterMode == ColumnFilterMode.DisplayText) {
  614. TextEdit textEdit = new TextEdit() { VerticalContentAlignment = settings.VerticalContentAlignment };
  615. settings.AssignViewInfoProperties(textEdit, Column);
  616. return textEdit;
  617. }
  618. ComboBoxEditSettings comboBoxEditSettings = settings as ComboBoxEditSettings;
  619. if(comboBoxEditSettings != null) {
  620. ComboBoxEdit comboBoxEdit = (ComboBoxEdit)comboBoxEditSettings.CreateEditor(false, EmptyDefaultEditorViewInfo.Instance);
  621. comboBoxEdit.ItemsSource = GetFilterComboBoxItems(comboBoxEdit.ItemsSource != null ? comboBoxEdit.ItemsSource : comboBoxEdit.Items);
  622. return comboBoxEdit;
  623. }
  624. return settings.CreateEditor(false, Column);
  625. }
  626. List<object> GetFilterComboBoxItems(IEnumerable items) {
  627. List<object> list = new List<object>();
  628. list.Add(new CustomComboBoxItem() { DisplayValue = string.Empty, EditValue = string.Empty });
  629. foreach(object item in items)
  630. list.Add(item);
  631. return list;
  632. }
  633. protected override void UpdateEditValue(BaseEdit editor) {
  634. editor.EditValue = Column.AutoFilterValue;
  635. }
  636. protected internal override bool PostEditor() {
  637. if(Edit.IsValueChanged) {
  638. Edit.FlushPendingEditActions();
  639. Column.AutoFilterValue = Edit.EditValue;
  640. }
  641. return true;
  642. }
  643. protected override void OnEditValueChanged() {
  644. if(Column.ImmediateUpdateAutoFilter)
  645. Column.AutoFilterValue = Edit.EditValue;
  646. }
  647. protected override void OnHiddenEditor() {
  648. Edit.EditValue = Column.AutoFilterValue;
  649. base.OnHiddenEditor();
  650. }
  651. protected override void OnColumnContentChanged(object sender, ColumnContentChangedEventArgs e) {
  652. if(e.Property == GridColumn.AutoFilterValueProperty) {
  653. Edit.EditValue = Column.AutoFilterValue;
  654. return;
  655. }
  656. if (e.Property == GridColumn.ColumnFilterModeProperty) {
  657. UpdateContent();
  658. return;
  659. }
  660. base.OnColumnContentChanged(sender, e);
  661. }
  662. protected override void SetDisplayTextProvider(BaseEdit newEdit) {
  663. }
  664. }
  665. public class NewItemRowCellEditor : CellEditor {
  666. protected override void OnEditValueChanged() {
  667. base.OnEditValueChanged();
  668. if(View.IsNewItemRowFocused && !View.DataProvider.IsNewItemRowEditing)
  669. (View as TableView).BeginNewItemRow();
  670. }
  671. protected override void OnPreviewKeyDown(KeyEventArgs e) {
  672. base.OnPreviewKeyDown(e);
  673. if(e.Key == Key.Enter && !IsEditorVisible)
  674. (View as TableView).MoveNextNewItemRowCell();
  675. }
  676. }
  677. public class CustomComboBoxItem : ICustomComboBoxItem {
  678. object displayValue;
  679. object editValue;
  680. public object DisplayValue {
  681. get { return displayValue; }
  682. set { displayValue = value; }
  683. }
  684. public object EditValue {
  685. get { return editValue; }
  686. set { editValue = value; }
  687. }
  688. }
  689. public interface IBaseEdit {
  690. void LockEditorFocus();
  691. void UnlockEditorFocus();
  692. bool NeedsKey(KeyEventArgs e);
  693. bool IsActivatingKey(KeyEventArgs e);
  694. void ProcessActivatingKey(KeyEventArgs e);
  695. bool IsReadOnly { get; set; }
  696. bool IsEditButtonsVisible { get; set; }
  697. bool IsEditorActive { get; }
  698. bool IsValueChanged { get; set; }
  699. EditMode EditMode { get; set; }
  700. object EditValue { get; set; }
  701. void SetKeyboardFocus();
  702. void SetValidationError(BaseValidationError validationError);
  703. bool IsChildElement(IInputElement element);
  704. void SetDisplayTemplate(ControlTemplate template);
  705. void SetEditTemplate(ControlTemplate template);
  706. void SelectAll();
  707. event EditValueChangedEventHandler EditValueChanged;
  708. void FlushPendingEditActions();
  709. bool DoValidate();
  710. }
  711. public class BaseEditWrapper : IBaseEdit {
  712. BaseEdit edit;
  713. public BaseEditWrapper(BaseEdit edit) {
  714. this.edit = edit;
  715. }
  716. void IBaseEdit.LockEditorFocus() {
  717. BaseEditHelper.LockEditorFocus(edit);
  718. }
  719. void IBaseEdit.UnlockEditorFocus() {
  720. BaseEditHelper.UnlockEditorFocus(edit);
  721. }
  722. bool IBaseEdit.NeedsKey(KeyEventArgs e) {
  723. return BaseEditHelper.GetNeedsKey(edit, e);
  724. }
  725. bool IBaseEdit.IsActivatingKey(KeyEventArgs e) {
  726. return BaseEditHelper.GetIsActivatingKey(edit, e);
  727. }
  728. void IBaseEdit.ProcessActivatingKey(KeyEventArgs e) {
  729. BaseEditHelper.ProcessActivatingKey(edit, e);
  730. }
  731. bool IBaseEdit.IsReadOnly { get { return edit.IsReadOnly; } set { edit.IsReadOnly = value; } }
  732. bool IBaseEdit.IsEditButtonsVisible { get { return edit.IsEditButtonsVisible; } set { edit.IsEditButtonsVisible = value; } }
  733. bool IBaseEdit.IsEditorActive { get { return edit.IsEditorActive; } }
  734. bool IBaseEdit.IsValueChanged { get { return BaseEditHelper.GetIsValueChanged(edit); } set { BaseEditHelper.SetIsValueChanged(edit, value); } }
  735. EditMode IBaseEdit.EditMode { get { return edit.EditMode; } set { edit.EditMode = value; } }
  736. object IBaseEdit.EditValue { get { return edit.EditValue; } set { edit.EditValue = value; } }
  737. void IBaseEdit.SetKeyboardFocus() {
  738. Keyboard.Focus(edit);
  739. }
  740. void IBaseEdit.SetValidationError(BaseValidationError validationError) {
  741. BaseEditHelper.SetValidationError(edit, validationError);
  742. }
  743. bool IBaseEdit.IsChildElement(IInputElement element) {
  744. return BaseEditHelper.GetIsChildElement(edit, element);
  745. }
  746. void IBaseEdit.SetDisplayTemplate(ControlTemplate template) {
  747. if(template != null)
  748. edit.DisplayTemplate = template;
  749. else
  750. edit.ClearValue(BaseEdit.DisplayTemplateProperty);
  751. }
  752. void IBaseEdit.SetEditTemplate(ControlTemplate template) {
  753. if(template != null)
  754. edit.EditTemplate = template;
  755. else
  756. edit.ClearValue(BaseEdit.EditTemplateProperty);
  757. }
  758. void IBaseEdit.SelectAll() {
  759. edit.SelectAll();
  760. }
  761. event EditValueChangedEventHandler IBaseEdit.EditValueChanged { 
  762. add { edit.EditValueChanged += value; } 
  763. remove { edit.EditValueChanged -= value; } 
  764. }
  765. void IBaseEdit.FlushPendingEditActions() {
  766. BaseEditHelper.FlushPendingEditActions(edit);
  767. }
  768. bool IBaseEdit.DoValidate() {
  769. return edit.DoValidate();
  770. }
  771. }
  772. public class FakeBaseEdit : IBaseEdit {
  773. public static readonly IBaseEdit Instance = new FakeBaseEdit();
  774. private FakeBaseEdit () {
  775. }
  776. void IBaseEdit.LockEditorFocus() { }
  777. void IBaseEdit.UnlockEditorFocus() { }
  778. bool IBaseEdit.NeedsKey(KeyEventArgs e) {
  779. return true;
  780. }
  781. bool IBaseEdit.IsActivatingKey(KeyEventArgs e) {
  782. return false;
  783. }
  784. void IBaseEdit.ProcessActivatingKey(KeyEventArgs e) { }
  785. bool IBaseEdit.IsReadOnly { get { return true; } set { } }
  786. bool IBaseEdit.IsEditButtonsVisible { get { return false; } set { } }
  787. bool IBaseEdit.IsEditorActive { get { return false; } }
  788. bool IBaseEdit.IsValueChanged { get { return false; } set { } }
  789. EditMode IBaseEdit.EditMode { get { return EditMode.InplaceInactive; } set { } }
  790. object IBaseEdit.EditValue { get { return null; } set { } }
  791. void IBaseEdit.SetKeyboardFocus() { }
  792. void IBaseEdit.SetValidationError(BaseValidationError validationError) { }
  793. bool IBaseEdit.IsChildElement(IInputElement element) { return false; }
  794. void IBaseEdit.SetDisplayTemplate(ControlTemplate template) { }
  795. void IBaseEdit.SetEditTemplate(ControlTemplate template) { }
  796. void IBaseEdit.SelectAll() { }
  797. event EditValueChangedEventHandler IBaseEdit.EditValueChanged { add { } remove { } }
  798. void IBaseEdit.FlushPendingEditActions() { }
  799. bool IBaseEdit.DoValidate() { return true; }
  800. }
  801. }