//Deserialization constructor.
 public SortInfo(SerializationInfo info, StreamingContext ctxt)
 {
     //Get the values from info and assign them to the appropriate properties
     _columnIndex = (int)info.GetValue("ColumnIndex", typeof(int));
     _propertyName = (String)info.GetValue("PropertyName", typeof(string));
     _direction = (ListSortDirection)info.GetValue("Direction", typeof(ListSortDirection));
 }

        public VarietiesViewModel(IProjectService projectService, IDialogService dialogService, IAnalysisService analysisService, VarietiesVarietyViewModel.Factory varietyFactory)
            : base("Varieties")
        {
            _projectService = projectService;
            _dialogService = dialogService;
            _analysisService = analysisService;
            _varietyFactory = varietyFactory;

            _projectService.ProjectOpened += _projectService_ProjectOpened;

            _sortPropertyName = "Meaning.Gloss";
            _sortDirection = ListSortDirection.Ascending;

            Messenger.Default.Register<SwitchViewMessage>(this, HandleSwitchView);

            _findCommand = new RelayCommand(Find);

            TaskAreas.Add(new TaskAreaItemsViewModel("Common tasks",
                    new TaskAreaCommandViewModel("Add a new variety", new RelayCommand(AddNewVariety)),
                    new TaskAreaCommandViewModel("Rename variety", new RelayCommand(RenameSelectedVariety, CanRenameSelectedVariety)),
                    new TaskAreaCommandViewModel("Remove variety", new RelayCommand(RemoveSelectedVariety, CanRemoveSelectedVariety)),
                    new TaskAreaCommandViewModel("Find words", _findCommand),
                    new TaskAreaItemsViewModel("Sort words by", new TaskAreaCommandGroupViewModel(
                        new TaskAreaCommandViewModel("Gloss", new RelayCommand(() => SortWordsBy("Meaning.Gloss", ListSortDirection.Ascending))),
                        new TaskAreaCommandViewModel("Form", new RelayCommand(() => SortWordsBy("StrRep", ListSortDirection.Ascending)))))));

            TaskAreas.Add(new TaskAreaItemsViewModel("Other tasks",
                new TaskAreaCommandViewModel("Remove affixes from words", new RelayCommand(RunStemmer, CanRunStemmer))));
        }

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

 private void _SetSortOrder( IEnumerable itemsSource, string propertyName, ListSortDirection direction )
 {
     var view = CollectionViewSource.GetDefaultView( itemsSource );
     view.SortDescriptions.Clear( );
     view.SortDescriptions.Add( new SortDescription( propertyName, direction ) );
     view.Refresh( );
 }

		public GroupColumn(string columnName,int groupLevel, ListSortDirection sortDirection):base(columnName,sortDirection)
		{
			this.groupLevel = groupLevel;
			if (groupLevel < 0) {
				throw new GroupLevelException();
			}
		}

        private void dataGrid1_Sorting(object sender, DataGridSortingEventArgs e)
        {
            sortMemberPath = e.Column.SortMemberPath;
            sortDirection = e.Column.SortDirection != ListSortDirection.Ascending ?
                ListSortDirection.Ascending : ListSortDirection.Descending;

        }

        private void Sort(string sortBy, ListSortDirection direction)
        {
            try
            {
                ICollectionView dataView = CollectionViewSource.GetDefaultView(listView_log.DataContext);

                dataView.SortDescriptions.Clear();

                SortDescription sd = new SortDescription(sortBy, direction);
                dataView.SortDescriptions.Add(sd);
                if (_lastHeaderClicked2 != null)
                {
                    if (String.Compare(sortBy, _lastHeaderClicked2) != 0)
                    {
                        SortDescription sd2 = new SortDescription(_lastHeaderClicked2, _lastDirection2);
                        dataView.SortDescriptions.Add(sd2);
                    }
                }
                dataView.Refresh();

                Settings.Instance.ResColumnHead = sortBy;
                Settings.Instance.ResSortDirection = direction;

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="SortGlyphAdorner"/> class.
 /// </summary>
 /// <param name="columnHeader">The column header</param>
 /// <param name="direction">The direction</param>
 /// <param name="sortGlyph">The image glyph</param>
 public SortGlyphAdorner(GridViewColumnHeader columnHeader, ListSortDirection direction, ImageSource sortGlyph)
     : base(columnHeader)
 {
     this.columnHeader = columnHeader;
     this.direction = direction;
     this.sortGlyph = sortGlyph;
 }

		internal Key(DataTable table,DataColumn[] columns,ListSortDirection[] sort, DataViewRowState rowState, IExpression filter)
		{
			_table = table;
			_filter = filter;
			if (_filter != null)
				_tmpRow = _table.NewNotInitializedRow();
			_columns = columns;
			if (sort != null && sort.Length == columns.Length) {
				_sortDirection = sort;
			}
			else {
				_sortDirection = new ListSortDirection[columns.Length];
				for(int i=0; i < _sortDirection.Length; i++) {
					_sortDirection[i] = ListSortDirection.Ascending;
				}
			}

			if (rowState != DataViewRowState.None) {
				_rowStateFilter = rowState;
			}
			else {
				// FIXME : what is the correct value ?
				_rowStateFilter = DataViewRowState.CurrentRows;
			}
		}

 public ColumnOrderSet(ColumnDefinition column, ListSortDirection order)
     : this()
 {
     column.ThrowIfNull("column");
     this.Column = column;
     this.Direction = order;
 }

 public ExtendedSortDescription(string property, ListSortDirection? sortDirection, bool clearPreviousSorting)
     : this()
 {
     this.Property = property;
     this.SortDirection = sortDirection;
     this.ClearPreviousSorting = clearPreviousSorting;
 }

        public void refreshOutgoing()
        {
            this.BeginInvoke((ThreadStart)delegate
            {
                int scrollPosition = dg_outgoing.FirstDisplayedScrollingRowIndex;

                DataGridViewColumn sortedColumn = dg_outgoing.SortedColumn;
                ListSortDirection sorder = new ListSortDirection();
                bool doSort = true;
                if (dg_outgoing.SortOrder == SortOrder.Ascending) sorder = ListSortDirection.Ascending;
                else if (dg_outgoing.SortOrder == SortOrder.Descending) sorder = ListSortDirection.Descending;
                else doSort = false;

                Point pp = Point.Empty;
                if (dg_outgoing.SelectedCells.Count > 0)
                    pp = dg_outgoing.CurrentCellAddress;

                dg_outgoing.Rows.Clear();
                foreach (DictionaryEntry de in mtOut.getMessages())
                {
                    canMessage cm = (canMessage)de.Key;
                    dg_outgoing.Rows.Add(cm.getDataGridViewRow(dg_outgoing,mtOut));
                }

                if (doSort) dg_outgoing.Sort(sortedColumn,(ListSortDirection) sorder);

                if (scrollPosition > 0) dg_outgoing.FirstDisplayedScrollingRowIndex = scrollPosition;

                if (dg_outgoing.Rows.Count > 0 && pp.Y < dg_outgoing.Rows.Count)
                    dg_outgoing.CurrentCell = dg_outgoing.Rows[pp.Y].Cells[pp.X];

            });
        }

 public SortExpression(string propertyName)
 {
     PropertyName = propertyName;
     SortDirection = ListSortDirection.Ascending;
     PropertyDescriptor = null;
     _propertyValueCache = new Hashtable();
 }

        public SortAdorner(UIElement element, ListSortDirection sortDirection)
            : base(element)
        {
            this.SortDirection  = sortDirection;

            this.PaintBrush     = ((element as GridViewColumnHeader).Column as DsxColumn).DataGrid.SortAdornerIndicatorBrush;
        }

 public SortDescriptionInfo(
   DataGridItemPropertyBase property,
   ListSortDirection direction )
 {
   m_property = property;
   m_direction = direction;
 }

 private void InternalSortColumn(int column, ListSortDirection? direction)
 {
     HDF hdf;
     if (this.ReadColumnFormat(column, out hdf))
     {
         hdf &= ~(HDF.HDF_SORTUP | HDF.HDF_SORTDOWN);
         if (direction.HasValue)
         {
             hdf |= (((ListSortDirection) direction.Value) == ListSortDirection.Descending) ? 0x200 : 0x400;
         }
         HDITEM hditem = new HDITEM {
             mask = HDI.HDI_FORMAT,
             fmt = hdf
         };
         GCHandle handle = GCHandle.Alloc(hditem, GCHandleType.Pinned);
         try
         {
             this.HeaderItemPtr = handle.AddrOfPinnedObject();
             Windows.SendMessage(base.Handle, 0x120c, (IntPtr) column, this.HeaderItemPtr);
         }
         finally
         {
             handle.Free();
             this.HeaderItemPtr = IntPtr.Zero;
         }
     }
 }

 public static void Sort(ItemsControl listView, string sortBy, ListSortDirection direction)
 {
     listView.Items.SortDescriptions.Clear();
     var sd = new SortDescription(sortBy, direction);
     listView.Items.SortDescriptions.Add(sd);
     listView.Items.Refresh();
 }

 public SortAdorner(UIElement element, ListSortDirection sortDirection)
     : base(element)
 {
     SortDirection = sortDirection;
     // We want to let the things we're adorning handle events
     IsHitTestVisible = false;
 }

 public void AddSort(string sortColumn, ListSortDirection dir)
 {
     if (sortColumns.ContainsKey(sortColumn))
         sortColumns.Remove(sortColumn);           
    
    sortColumns.Add(sortColumn, dir);
 }

 public FileListPaneSettings(string directory, string sortByField, ListSortDirection sortDirection, ColumnMode columnMode)
 {
     Directory = directory;
     SortByField = sortByField;
     SortDirection = sortDirection;
     DisplayColumnMode = columnMode;
 }