Beispiel #1
0
        internal void RaiseAutomationInvokeEvents(DataGridEditingUnit editingUnit, DataGridColumn column, DataGridRow row)
        {
            switch (editingUnit)
            {
            case DataGridEditingUnit.Cell:
            {
                DataGridCell   cell = row.Cells[column.Index];
                AutomationPeer peer = FromElement(cell);
                if (peer != null)
                {
                    peer.InvalidatePeer();
                }
                else
                {
                    peer = CreatePeerForElement(cell);
                }

                if (peer != null)
                {
                    peer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
                }
                break;
            }

            case DataGridEditingUnit.Row:
            {
                DataGridItemAutomationPeer peer = GetOrCreateItemPeer(row.DataContext);
                peer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
                break;
            }
            }
        }
 public DataGridEndingEditEventArgs(DataGridColumn column,
                                    DataGridRow row,
                                    FrameworkElement editingElement,
                                    DataGridEditingUnit editingUnit)
 {
     this.Column = column;
     this.Row = row;
     this.EditingElement = editingElement;
     this.EditingUnit = editingUnit;
 }
 public DataGridEndingEditEventArgs(DataGridColumn column,
                                    DataGridRow row,
                                    FrameworkElement editingElement,
                                    DataGridEditingUnit editingUnit)
 {
     this.Column         = column;
     this.Row            = row;
     this.EditingElement = editingElement;
     this.EditingUnit    = editingUnit;
 }
Beispiel #4
0
 /// <summary>
 ///     Raises the CancelEdit command.
 ///     Reverts any pending editing changes to the desired editing unit and exits edit mode.
 /// </summary>
 /// <param name="editingUnit">Whether to cancel edit mode of the current cell or current row.</param>
 /// <returns>true if the current cell or row exits edit mode, false otherwise.</returns>
 public bool CancelEdit(DataGridEditingUnit editingUnit)
 {
     return EndEdit(CancelEditCommand, CurrentCellContainer, editingUnit, true);
 }
 private bool CanCancelAddingOrEditingRowItem(DataGridEditingUnit editingUnit, object item)
 {
     return (editingUnit == DataGridEditingUnit.Row) &&
            ((IsEditingItem(item) && EditableItems.CanCancelEdit) ||
            (IsAddingNewItem && (EditableItems.CurrentAddItem == item)));
 }
 public bool CommitEdit(DataGridEditingUnit editingUnit, bool exitEditingMode)
 {
     return(default(bool));
 }
 public bool CancelEdit(DataGridEditingUnit editingUnit)
 {
     return(default(bool));
 }
 public bool CommitEdit(DataGridEditingUnit editingUnit, bool exitEditingMode)
 {
   return default(bool);
 }
Beispiel #9
0
 private bool IsAddingOrEditingRowItem(DataGridEditingUnit editingUnit, object item)
 {
     return (editingUnit == DataGridEditingUnit.Row) &&
             IsAddingOrEditingRowItem(item);
 }
 /// <summary>
 /// Commits editing mode for the specified DataGridEditingUnit and pushes changes to the backend.
 /// </summary>
 /// <param name="editingUnit">Specifies whether to commit edit for a Cell or Row.</param>
 /// <param name="exitEditingMode">Editing mode is left if True.</param>
 /// <returns>True if operation was successful. False otherwise.</returns>
 public bool CommitEdit(DataGridEditingUnit editingUnit, bool exitEditingMode)
 {
     if (!EndCellEdit(DataGridEditAction.Commit, editingUnit == DataGridEditingUnit.Cell ? exitEditingMode : true, this.ContainsFocus /*keepFocus*/, true /*raiseEvents*/))
     {
         return false;
     }
     if (editingUnit == DataGridEditingUnit.Row)
     {
         return EndRowEdit(DataGridEditAction.Commit, exitEditingMode, true /*raiseEvents*/);
     }
     return true;
 }
 /// <summary>
 /// Cancels editing mode for the specified DataGridEditingUnit and restores its original value.
 /// </summary>
 /// <param name="editingUnit">Specifies whether to cancel edit for a Cell or Row.</param>
 /// <returns>True if operation was successful. False otherwise.</returns>
 public bool CancelEdit(DataGridEditingUnit editingUnit)
 {
     return this.CancelEdit(editingUnit, true /*raiseEvents*/);
 }
Beispiel #12
0
 /// <summary>
 /// Commits editing mode for the specified DataGridEditingUnit and pushes changes to the backend.
 /// </summary>
 /// <param name="editingUnit">Specifies whether to commit edit for a Cell or Row.</param>
 /// <param name="exitEditingMode">Editing mode is left if True.</param>
 /// <returns>True if operation was successful. False otherwise.</returns>
 public bool CommitEdit(DataGridEditingUnit editingUnit, bool exitEditingMode)
 {
     if (!EndCellEdit(true, exitEditingMode, this.ContainsFocus /*keepFocus*/))
     {
         return false;
     }
     if (editingUnit == DataGridEditingUnit.Row)
     {
         return EndRowEdit(true, exitEditingMode);
     }
     return true;
 }
Beispiel #13
0
 /// <summary>
 /// Cancels editing mode for the specified DataGridEditingUnit and restores its original value.
 /// </summary>
 /// <param name="editingUnit">Specifies whether to cancel edit for a Cell or Row.</param>
 /// <returns>True if operation was successful. False otherwise.</returns>
 public bool CancelEdit(DataGridEditingUnit editingUnit)
 {
     if (!EndCellEdit(false, true, this.ContainsFocus /*keepFocus*/))
     {
         return false;
     }
     if (editingUnit == DataGridEditingUnit.Row)
     {
         return EndRowEdit(false, true);
     }
     return true;
 }
Beispiel #14
0
 /// <summary>
 ///     Raises the CommitEdit command.
 ///     Commits any pending changes for the given editing unit and exits edit mode.
 /// </summary>
 /// <param name="editingUnit">Whether to commit changes for the current cell or current row.</param>
 /// <param name="exitEditingMode">Whether to exit edit mode.</param>
 /// <returns>true if the current cell or row exits edit mode, false otherwise.</returns>
 public bool CommitEdit(DataGridEditingUnit editingUnit, bool exitEditingMode)
 {
     return EndEdit(CommitEditCommand, CurrentCellContainer, editingUnit, exitEditingMode);
 }
 /// <summary>
 /// Cancels editing mode for the specified DataGridEditingUnit and restores its original value.
 /// </summary>
 /// <param name="editingUnit">Specifies whether to cancel edit for a Cell or Row.</param>
 /// <param name="raiseEvents">Specifies whether or not to raise editing events</param>
 /// <returns>True if operation was successful. False otherwise.</returns>
 internal bool CancelEdit(DataGridEditingUnit editingUnit, bool raiseEvents)
 {
     if (!EndCellEdit(DataGridEditAction.Cancel, true, this.ContainsFocus /*keepFocus*/, raiseEvents))
     {
         return false;
     }
     if (editingUnit == DataGridEditingUnit.Row)
     {
         return EndRowEdit(DataGridEditAction.Cancel, true, raiseEvents);
     }
     return true;
 }
Beispiel #16
0
        private bool EndEdit(RoutedCommand command, DataGridCell cellContainer, DataGridEditingUnit editingUnit, bool exitEditMode)
        {
            bool cellLeftEditingMode = true;
            bool rowLeftEditingMode = true;

            if (cellContainer != null)
            {
                if (command.CanExecute(editingUnit, cellContainer))
                {
                    command.Execute(editingUnit, cellContainer);
                }

                cellLeftEditingMode = !cellContainer.IsEditing;
                rowLeftEditingMode = !IsEditingRowItem && !IsAddingNewItem;
            }

            if (!exitEditMode)
            {
                if (editingUnit == DataGridEditingUnit.Cell)
                {
                    if (cellContainer != null)
                    {
                        if (cellLeftEditingMode)
                        {
                            return BeginEdit(null);
                        }
                    }
                    else
                    {
                        // A cell was not placed in edit mode
                        return false;
                    }
                }
                else
                {
                    if (rowLeftEditingMode)
                    {
                        object rowItem = cellContainer.RowDataItem;
                        if (rowItem != null)
                        {
                            EditRowItem(rowItem);
                            return IsEditingRowItem;
                        }
                    }

                    // A row item was not placed in edit mode
                    return false;
                }
            }

            return cellLeftEditingMode && ((editingUnit == DataGridEditingUnit.Cell) || rowLeftEditingMode);
        }
        internal void RaiseAutomationInvokeEvents(DataGridEditingUnit editingUnit, DataGridColumn column, DataGridRow row)
        {
            switch (editingUnit)
            {
                case DataGridEditingUnit.Cell:
                    {
                        DataGridCell cell = row.Cells[column.Index];
                        AutomationPeer peer = FromElement(cell);
                        if (peer != null)
                        {
                            peer.InvalidatePeer();
                        }
                        else
                        {
                            peer = CreatePeerForElement(cell);
                        }

                        if (peer != null)
                        {
                            peer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
                        }
                        break;
                    }
                case DataGridEditingUnit.Row:
                    {
                        DataGridItemAutomationPeer peer = GetOrCreateItemPeer(row.DataContext);
                        peer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
                        break;
                    }
            }
        }
 internal bool CommitEdit(DataGridEditingUnit dataGridEditingUnit, bool exitEditingMode)
 {
     return(DataGrid.CommitEdit(dataGridEditingUnit, exitEditingMode));
 }
 public bool CancelEdit(DataGridEditingUnit editingUnit)
 {
   return default(bool);
 }