/// <summary>
 ///     Constructs a new instance of these event arguments. 
 /// </summary>
 /// <param name="column">The column of the cell that just entered edit mode.</param>
 /// <param name="row">The row container that contains the cell container that just entered edit mode.</param>
 /// <param name="editingEventArgs">The event arguments, if any, that led to the cell being placed in edit mode.</param> 
 /// <param name="cell">The cell container that just entered edit mode.</param>
 /// <param name="editingElement">The editing element within the cell container.</param> 
 public DataGridPreparingCellForEditEventArgs(DataGridColumn column, DataGridRow row, RoutedEventArgs editingEventArgs, FrameworkElement editingElement) 
 {
     _dataGridColumn = column; 
     _dataGridRow = row;
     _editingEventArgs = editingEventArgs;
     _editingElement = editingElement;
 } 

 /// <summary>
 ///     Instantiates a new instance of this class.
 /// </summary>
 /// <param name="column">The column of the cell that is about to exit edit mode.</param>
 /// <param name="row">The row container of the cell container that is about to exit edit mode.</param>
 /// <param name="editingElement">The editing element within the cell.</param>
 /// <param name="editingUnit">The editing unit that is about to leave edit mode.</param>
 public DataGridCellEditEndingEventArgs(DataGridColumn column, DataGridRow row, FrameworkElement editingElement, DataGridEditAction editAction)
 {
     _dataGridColumn = column;
     _dataGridRow = row;
     _editingElement = editingElement;
     _editAction = editAction;
 }

 /// <summary>
 /// AutomationPeer for DataGridRow
 /// </summary>
 /// <param name="owner">DataGridRow</param>
 public DataGridRowAutomationPeer(DataGridRow owner)
     : base(owner)
 {
     if (owner == null)
     {
         throw new ArgumentNullException("owner");
     }
 }

 private void FormatRow(DataGridRow row)
 {
     Product product = (Product)row.DataContext;
     if (product.UnitCost > 100)
         row.Background = highlightBrush;
     else
         row.Background = normalBrush;
 }   

 /// <summary>
 /// Initializes a new instance of the 
 /// <see cref="T:System.Windows.Controls.Data.DataGridBeginningEditEventArgs" /> class.
 /// </summary>
 /// <param name="column">
 /// The column that contains the cell to be edited.
 /// </param>
 /// <param name="row">
 /// The row that contains the cell to be edited.
 /// </param>
 /// <param name="editingEventArgs">
 /// Information about the user gesture that caused the cell to enter edit mode.
 /// </param>
 public DataGridBeginningEditEventArgs(DataGridColumn column,
                                       DataGridRow row,
                                       RoutedEventArgs editingEventArgs)
 {
     this.Column = column;
     this.Row = row;
     this.EditingEventArgs = editingEventArgs;
 }

 public void Update(DataGridRow row)
 {
     var record = (Record)row.Item;
     var content = GetContent(row);
     if (content == null)
     {
         return;
     }
     content.Text = record.Properties[_descriptor.Index].ValueAsString;
 }

 public void GridRowNumberConverter_Convert_WhenInputIsEmpty_ReturnsAZero()
 {
     //------------Setup for test--------------------------
     var converter = new GridRowNumberConverter();
     DataGrid dataGrid = new DataGrid { AutoGenerateColumns = true };
     var itemsSource = new List<string> { "Item 1 ", "Item 2" };
     dataGrid.ItemsSource = itemsSource;
     dataGrid.SelectedItem = itemsSource[0];
     var row = new DataGridRow();
     //------------Execute Test---------------------------
     var result = converter.Convert(row, typeof(string), null, CultureInfo.CurrentCulture);
     //------------Assert Results-------------------------
     Assert.AreEqual(0, result);
 }

        /// <summary>
        /// Collapse/Expands the selected DataGridRow.
        /// </summary>
        /// <param name="parameter">The DataGridRowHeader</param>
        public void Execute(object parameter)
        {
            var rowHeader = parameter as DataGridRowHeader;
            var row = DataGridHelper.FindTemplatedParent<DataGridRow>(rowHeader) as DataGridRow;
            if (_prevRow is DataGridRow
                && _prevRow != row
                && DataGridHelper.FindVisualParent<DataGrid>(_prevRow) == DataGridHelper.FindVisualParent<DataGrid>(rowHeader))
            {	//collapse the previously selected row
                _prevRow.DetailsVisibility = Visibility.Collapsed;
            }
            if (row.DetailsVisibility == Visibility.Visible)
                row.DetailsVisibility = Visibility.Collapsed;
            else
                row.DetailsVisibility = Visibility.Visible;

            _prevRow = row;
        }

        public void SetRowLogo(DataGrid DtGrid, DataGridRow row, string entityCode)
        {
            if (DtGrid.ItemsSource == null)
            {
                return;
            }

            Image logo = DtGrid.Columns[0].GetCellContent(row).FindName("entityLogo") as Image;
            if (logo == null)
            {
                return;
            }

            if (Application.Current.Resources["RowLogo" + entityCode] != null)
            {
                string strPpath = Application.Current.Resources["RowLogo" + entityCode].ToString();
                logo.Margin = new Thickness(2, 2, 0, 0);
                logo.Source = new System.Windows.Media.Imaging.BitmapImage(new Uri(strPpath, UriKind.Relative));
                return;
            }

            SMT.Saas.Tools.PermissionWS.PermissionServiceClient client = new SMT.Saas.Tools.PermissionWS.PermissionServiceClient();
            client.GetSysMenuByEntityCodeCompleted += new EventHandler<SMT.Saas.Tools.PermissionWS.GetSysMenuByEntityCodeCompletedEventArgs>(client_GetSysMenuByEntityCodeCompleted);
            client.GetSysMenuByEntityCodeAsync(entityCode);

            //if (string.IsNullOrEmpty(EntityLogo))
            //{
            //    SMT.Saas.Tools.PermissionWS.PermissionServiceClient client = new SMT.Saas.Tools.PermissionWS.PermissionServiceClient();
            //    client.GetSysMenuByEntityCodeCompleted += new EventHandler<SMT.Saas.Tools.PermissionWS.GetSysMenuByEntityCodeCompletedEventArgs>(client_GetSysMenuByEntityCodeCompleted);
            //    client.GetSysMenuByEntityCodeAsync(entityCode, logo);
            //}
            //else
            //{
            //    logo.Source = new System.Windows.Media.Imaging.BitmapImage(new Uri(EntityLogo, UriKind.Relative));
            //}
        }

 /// <summary>
 /// Gets the is read only flag for the row.
 /// </summary>
 /// <param name="dataGridRow">The data grid row.</param>
 /// <returns><c>true</c> if the row is read only, otherwise <c>false</c>.</returns>
 public static bool GetIsReadOnly(DataGridRow dataGridRow)
 {
     return (bool)dataGridRow.GetValue(IsReadOnlyProperty);
 }

 /// <summary>
 /// Sets the drag format when this instance is being dragged above or below another row.
 /// </summary>
 /// <param name="dataGridRow">The data grid row.</param>
 /// <param name="format">The drag format used when this instance is being dragged above or below another row.</param>
 public static void SetMoveDragFormat(DataGridRow dataGridRow, string format)
 {
     dataGridRow.SetValue(MoveDragFormatProperty, format);
 }

 /// <summary>
 /// Gets the deselection enabled property. If enabled, and the row is clicked while selected, the row is deselected.
 /// </summary>
 /// <param name="dataGridRow">The data grid row.</param>
 /// <returns><c>true</c> if deselecting row when selected and clicked, otherwise <c>false</c>.</returns>
 public static bool GetIsDeselectionEnabled(DataGridRow dataGridRow)
 {
     return (bool)dataGridRow.GetValue(IsDeselectionEnabledProperty);
 }

 /// <summary>
 /// Sets the command used to move another row below this one using drag and drop.
 /// </summary>
 /// <param name="dataGridRow">The data grid row.</param>
 /// <param name="command">The command to move a row below this instance.</param>
 public static void SetMoveBelowCommand(DataGridRow dataGridRow, ICommand command)
 {
     dataGridRow.SetValue(MoveBelowCommandProperty, command);
 }

 /// <summary>
 /// Sets the content template when this instance is being dragged above or below another row.
 /// </summary>
 /// <param name="dataGridRow">The data grid row.</param>
 /// <param name="value">A data template used when this instance is being dragged above or below another row.</param>
 public static void SetMoveDragContentTemplate(DataGridRow dataGridRow, DataTemplate value)
 {
     dataGridRow.SetValue(MoveDragContentTemplateProperty, value);
 }

        /// <summary>
        ///     Retrieves the visual tree that was generated for a particular row and column.
        /// </summary>
        /// <param name="dataGridRow">The row that corresponds to the desired cell.</param>
        /// <returns>The element if found, null otherwise.</returns>
        public FrameworkElement GetCellContent(DataGridRow dataGridRow)
        {
            if (dataGridRow == null)
            {
                throw new ArgumentNullException("dataGridRow");
            }

            if (_dataGridOwner != null)
            {
                int columnIndex = _dataGridOwner.Columns.IndexOf(this);
                if (columnIndex >= 0)
                {
                    DataGridCell cell = dataGridRow.TryGetCell(columnIndex);
                    if (cell != null)
                    {
                        return cell.Content as FrameworkElement;
                    }
                }
            }

            return null;
        }

 // This method is called from DataGrid.OnBeginningEdit/OnCommittingEdit/OnCancelingEdit
 // Raises Invoked event when cell begin/cancel/commit edit
 internal void RaiseAutomationCellInvokeEvents(DataGridColumn column, DataGridRow row)
 {
     DataGridItemAutomationPeer dataGridItemAutomationPeer = FindOrCreateItemAutomationPeer(row.Item) as DataGridItemAutomationPeer;
     if (dataGridItemAutomationPeer != null)
     {
         DataGridCellItemAutomationPeer cellPeer = dataGridItemAutomationPeer.GetOrCreateCellItemPeer(column);
         if (cellPeer != null)
         {
             cellPeer.RaiseAutomationEvent(AutomationEvents.InvokePatternOnInvoked);
         }
     }
 }

//.........这里部分代码省略.........
                            }
                        }

                        foreach (KeyValuePair<DataTable, List<DescriptiveStatistics>> tableKvp in stratifiedFrequencyTables)
                        {
                            string strataValue = tableKvp.Key.TableName;

                            double count = 0;
                            foreach (DescriptiveStatistics ds in tableKvp.Value)
                            {
                                count = count + ds.observations;
                            }

                            if (count == 0)
                            {
                                continue;
                            }
                            DataTable frequencies = tableKvp.Key;

                            if (frequencies.Rows.Count == 0)
                            {
                                continue;
                            }

                            string tableHeading = tableKvp.Key.TableName;

                            if (stratifiedFrequencyTables.Count > 1)
                            {
                                tableHeading = freqVar;
                            }

                            double lastAvg = double.NegativeInfinity;
                            double lastStdDev = double.NegativeInfinity;
                            Queue<double> frame = new Queue<double>();
                            List<SimpleDataValue> actualValues = new List<SimpleDataValue>();
                            List<SimpleDataValue> trendValues = new List<SimpleDataValue>();
                            List<SimpleDataValue> aberrationValues = new List<SimpleDataValue>();
                            List<DataGridRow> aberrationDetails = new List<DataGridRow>();
                            int rowCount = 1;
                            foreach (System.Data.DataRow row in frequencies.Rows)
                            {
                                if (!row[freqVar].Equals(DBNull.Value) || (row[freqVar].Equals(DBNull.Value) && includeMissing == true))
                                {
                                    DateTime displayValue = DateTime.Parse(row[freqVar].ToString());

                                    frame.Enqueue((double)row["freq"]);
                                    SimpleDataValue actualValue = new SimpleDataValue();
                                    actualValue.IndependentValue = displayValue;
                                    actualValue.DependentValue = (double)row["freq"];
                                    actualValues.Add(actualValue);
                                    if (frame.Count > lagTime - 1 /*6*/)
                                    {
                                        double[] frameArray = frame.ToArray();
                                        double frameAvg = frameArray.Average();
                                        frame.Dequeue();
                                        double stdDev = CalculateStdDev(frameArray);
                                        if (lastAvg != double.NegativeInfinity)
                                        {
                                            SimpleDataValue trendValue = new SimpleDataValue();
                                            trendValue.IndependentValue = displayValue;
                                            trendValue.DependentValue = lastAvg;
                                            trendValues.Add(trendValue);
                                            if ((double)row["freq"] > lastAvg + (/*2.99*/deviations * lastStdDev))
                                            {
                                                SimpleDataValue aberrationValue = new SimpleDataValue();
                                                aberrationValue.IndependentValue = displayValue;
                                                aberrationValue.DependentValue = (double)row["freq"];
                                                aberrationValues.Add(aberrationValue);
                                                DataGridRow aberrationDetail = new DataGridRow()
                                                {
                                                    Date = displayValue,
                                                    Frequency = (double)row["freq"],
                                                    RunningAverage = lastAvg,
                                                    StandardDeviation = lastStdDev
                                                };
                                                aberrationDetails.Add(aberrationDetail);
                                            }
                                        }
                                        lastAvg = frameAvg;
                                        lastStdDev = stdDev;
                                    }

                                    rowCount++;
                                }
                            }

                            this.Dispatcher.BeginInvoke(setGraph, strataValue, actualValues, trendValues, aberrationValues, aberrationDetails);
                            System.Threading.Thread.Sleep(1000);
                        }
                    }
                    this.Dispatcher.BeginInvoke(new SimpleCallback(RenderFinish));
                    this.Dispatcher.BeginInvoke(new SimpleCallback(SetGadgetToFinishedState));
                }
                catch (Exception ex)
                {
                    this.Dispatcher.BeginInvoke(new RenderFinishWithErrorDelegate(RenderFinishWithError), ex.Message);
                    this.Dispatcher.BeginInvoke(new SimpleCallback(SetGadgetToFinishedState));
                }
            }
        }

 /// <summary>
 /// Gets the drag format when this instance is being dragged above or below another row.
 /// </summary>
 /// <param name="dataGridRow">The data grid row.</param>
 /// <returns>The drag format used when this instance is being dragged above or below another row.</returns>
 public static string GetMoveDragFormat(DataGridRow dataGridRow)
 {
     return (string)dataGridRow.GetValue(MoveDragFormatProperty);
 }

 private void PickUpCard(object sender, MouseEventArgs e)
 {
     if (MouseButtonState.Pressed.Equals(e.LeftButton) && dragActive)
     {
         DataGridRow SearchCard = new DataGridRow();
         var row = (DataRowView)resultsGrid.SelectedItem;
         if (row == null) return;
         if (CardAdded == null) return;
         var rowid = row["id"] as string;
         if (rowid != null)
         {
             DataNew.Entities.MultiCard getCard = Game.GetCardById(Guid.Parse(rowid)).ToMultiCard();
             DataObject dragCard = new DataObject("Card", getCard);
             DragDrop.DoDragDrop(SearchCard, dragCard, DragDropEffects.Copy);
         }
     }
     dragActive = false;
 }

 static void MessageBoxEvent(DataGridRow item)
 {
     item.Selected += delegate
     {
         MessageBox.Show("");
     };
 }