public CaseListSort(ListSortDirection direction, DataGridColumn column)
        {
           int dir = (direction == ListSortDirection.Ascending) ? 1: -1;

            string path = BindingOperations.GetBindingExpression(column, DataGridColumn.HeaderProperty).ParentBinding.Path.Path;
            switch (path)
            {
                case "CaseId":
                    myComparer = (a, b) => { return a.CaseId.CompareTo(b.CaseId) * dir; };
                    break;

                case "AnalystComment":
                    myComparer = (a, b) => { return a.AnalystComment.CompareTo(b.AnalystComment) * dir;};
                    break;

                case "ObjectId":
                    myComparer = (a, b) => { return a.ObjectId.CompareTo(b.ObjectId) * dir;};
                    break;

                case "FlightNumber":
                    myComparer = (a, b) => { return a.FlightNumber.CompareTo(b.FlightNumber) * dir; };
                    break;

                case "Analyst":
                    myComparer = (a, b) => { return a.Analyst.CompareTo(b.Analyst) * dir; };
                    break;

                case "CaseDirectory":
                    myComparer = (a, b) => { return a.CaseDirectory.CompareTo(b.CaseDirectory) * dir; };
                    break;

                case "ReferenceImage":
                    myComparer = (a, b) => { return a.ReferenceImage.CompareTo(b.ReferenceImage) * dir; };
                    break;

                case "Result":
                    myComparer = (a, b) => { return a.Result.CompareTo(b.Result) * dir; };
                    break;

                case "UpdateTime":
                    myComparer = (a, b) => { return a.UpdateTime.CompareTo(b.UpdateTime) * dir; };
                    break;

                case "CreateTime":
                    myComparer = (a, b) => { return a.CreateTime.CompareTo(b.CreateTime) * dir; };
                    break;

                case "Archived":
                    myComparer = (a, b) => { return a.Archived.CompareTo(b.Archived) * dir; };
                    break;
                    
                case "AnalysisTime":
                    myComparer = (a, b) => { return a.AnalysisTime.CompareTo(b.AnalysisTime) * dir; };
                    break;

                default:
                    myComparer = (a, b) => { return 0; };
                    break;
            }
        }

        internal bool GetColumnReadOnlyState(DataGridColumn dataGridColumn, bool isReadOnly)
        {
            Debug.Assert(dataGridColumn != null);

            DataGridBoundColumn dataGridBoundColumn = dataGridColumn as DataGridBoundColumn;
            if (dataGridBoundColumn != null && dataGridBoundColumn.Binding != null)
            {
                string path = null;
                if (dataGridBoundColumn.Binding.Path != null)
                {
                    path = dataGridBoundColumn.Binding.Path.Path;
                }

                if (!string.IsNullOrEmpty(path))
                {
                    if (dataGridBoundColumn.IsAutoGenerated)
                    {
                        Type type = null;
                        if (DataConnection.DataType != null)
                        {
                            type = DataConnection.DataType.GetNestedPropertyType(path);
                        }

                        if (type != null && !DataGridDataConnection.CanEdit(type))
                        {
                            return true;
                        }
                    }
                    return this.DataConnection.GetPropertyIsReadOnly(path) || isReadOnly;
                }
            }

            return isReadOnly;
        }

 public ColumnInformation(DataGridColumn column)
 {
     Header = column.Header;
     if (!(column is DataGridTemplateColumn))
     {
         try
         {
             if (column is DataGridComboBoxColumn)
                 PropertyPath = column.SortMemberPath;
             else
                 PropertyPath = ((Binding)((DataGridBoundColumn)column).Binding).Path.Path;
         }
         catch
         {
             PropertyPath = string.Empty;
         }
     }
     else
     {
         PropertyPath = column.SortMemberPath;
     }
     WidthValue = column.Width.DisplayValue;
     WidthType = column.Width.UnitType;
     SortDirection = column.SortDirection;
     DisplayIndex = column.DisplayIndex;
     SortMemberPath = column.SortMemberPath;
     IsVisible = column.Visibility == Visibility.Visible;
 }

 /// <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;
 }

        public static string GetSortMemberPath(DataGridColumn column)
        {
            string sortPropertyName = column.SortMemberPath;
            if (string.IsNullOrEmpty(sortPropertyName))
            {
                var boundColumn = column as DataGridBoundColumn;
                if (boundColumn != null)
                {
                    var binding = boundColumn.Binding as Binding;
                    if (binding != null)
                    {
                        if (!string.IsNullOrEmpty(binding.XPath))
                        {
                            sortPropertyName = binding.XPath;
                        }
                        else if (binding.Path != null)
                        {
                            sortPropertyName = binding.Path.Path;
                        }
                    }
                }
            }

            return sortPropertyName;
        }

 /// <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;
 } 

        private void AddEventHandlers(DataGridColumn column)
        {
            Contract.Requires(column != null);

            VisibilityPropertyDescriptor.AddValueChanged(column, DataGridColumnVisibility_Changed);
            ActualWidthPropertyDescriptor.AddValueChanged(column, DataGridColumnActualWidth_Changed);
            DisplayIndexPropertyDescriptor.AddValueChanged(column, DataGridColumnDisplayIndex_Changed);
        }

 private void applySortDirection(DataGrid grid, DataGridColumn col, ListSortDirection listSortDirection)
 {
     foreach (DataGridColumn c in grid.Columns)
     {
         c.SortDirection = null;
     }
     col.SortDirection = listSortDirection;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="T:System.Windows.Controls.Data.DataGridColumnEventArgs" /> class.
 /// </summary>
 /// <param name="column">The column that the event occurs for.</param>
 public DataGridColumnEventArgs(DataGridColumn column)
 {
     if (column == null)
     {
         throw new ArgumentNullException("column");
     }
     this.Column = column;
 }

        // !!!!!!!!!DataGridColumn
        /// <summary>
        /// Initializes a new instance of the XHtmlTextBoxCell class.
        /// </summary>
        public XHtmlGenericCell(DataGridColumn column)
        {
            Presentation = new XHtmlPresentationCell();

            //			this.column = column as XHtmlTextBoxColumn;

            SetStyle();
        }

 /// <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 ITreeModel Sort(ListSortDirection lsd, DataGridColumn column)
        {
            MylistModel model = new MylistModel(m_myList);
            model.m_currentSort = new SortDescription { direction = lsd, column = column };

            model.Root.Sort(new MylistSort(lsd, column));

            return model;
        }

 public DataGridColumnInfo(DataGridColumn column)
 {
     IsVisible = column.Visibility == System.Windows.Visibility.Visible;
     DisplayIndex = column.DisplayIndex;
     if (column.Width.IsAuto)
         WidthValue = null;
     else
         WidthValue = column.Width.DisplayValue;
 }

        internal DataGridCellInfo(object item, DataGridColumn column, DataGrid owner)
        {
            Debug.Assert(item != null, "item should not be null.");
            Debug.Assert(column != null, "column should not be null.");
            Debug.Assert(owner != null, "owner should not be null.");

            _info = owner.NewItemInfo(item);
            _column = column;
            _owner = new WeakReference(owner);
        }

 public DataGridColumnInfo(DataGridColumn column)
     : this()
 {
     this.DisplayIndex = column.DisplayIndex;
     this.Name = AutomationProperties.GetName(column);
     this.SortDirection = column.SortDirection;
     this.Visibility = column.Visibility;
     this.WidthType = column.Width.UnitType;
     this.WidthValue = column.Width.DisplayValue;
 }

 public void DoDataGridColumn(ExDataGrid _dg, int _waitTime, DataGridColumn _dataGridColumn)
 {
     BackgroundWorker bw = new BackgroundWorker();
     dg = _dg;
     waitTime = _waitTime;
     dataGridColumn = _dataGridColumn;
     bw.DoWork -= new DoWorkEventHandler(bw_DoDataGridColumn);
     bw.DoWork += new DoWorkEventHandler(bw_DoDataGridColumn);
     bw.RunWorkerAsync();
 }

        /// <summary>
        ///     Identifies a cell at the column within the row for the specified item. 
        /// </summary>
        /// <param name="item">The item who's row contains the cell.</param>
        /// <param name="column">The column of the cell within the row.</param>
        /// <remarks> 
        ///     This constructor will not tie the DataGridCellInfo to any particular
        ///     DataGrid. 
        /// </remarks> 
        public DataGridCellInfo(object item, DataGridColumn column)
        { 
            if (column == null)
            {
                throw new ArgumentNullException("column");
            } 

            _item = item; 
            _column = column; 
            _owner = null;
        } 

 internal DataGridAutoGeneratingColumnEventArgs(
     DataGridColumn column,
     string propertyName, 
     Type propertyType,
     object propertyDescriptor) 
 { 
     _column = column;
     _propertyName = propertyName; 
     _propertyType = propertyType;
     PropertyDescriptor = propertyDescriptor;
 }

 public void Apply(DataGridColumn column, int gridColumnCount)
 {
     column.Visibility = IsVisible ? System.Windows.Visibility.Visible : System.Windows.Visibility.Collapsed;
     var maxIndex = (gridColumnCount == 0) ? 0 : gridColumnCount - 1;
     column.DisplayIndex = (DisplayIndex <= maxIndex) ? DisplayIndex : maxIndex;
     if (column.CanUserResize)
     {
         if (WidthValue.HasValue)
             column.Width = new DataGridLength(WidthValue.Value);
     }
 }

        public void Apply(DataGridColumn column, int gridColumnCount)
        {
            if (column.DisplayIndex != this.DisplayIndex)
            {
                var maxIndex = (gridColumnCount == 0) ? 0 : gridColumnCount - 1;
                column.DisplayIndex = (this.DisplayIndex <= maxIndex) ? this.DisplayIndex : maxIndex;
            }

            column.SortDirection = this.SortDirection;
            column.Visibility = this.Visibility;
            column.Width = new DataGridLength(this.WidthValue, this.WidthType);
        }